From 9ae3b26530282ff2dd33f38acf3624470db20b9a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Carlos=20Michel=20Mourra=20D=C3=ADaz?= <60996279+MichMourra@users.noreply.github.com> Date: Sat, 10 Sep 2022 22:35:45 -0500 Subject: [PATCH] Sugerencias Tarea 2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Excelente código 😄 , cumples con todos los requisitos establecidos en la rúbrica de evaluación. De igual manera es posible apreciar que aprendiste de una manera adecuada el uso de diccionarios y expresiones regulares. En cuanto a tu repositorio de GitHub cumple con todo lo visto en las clases anteriores: Usas tags, resuelves Issues y utilizas dos ramas para tus proyectos. Me gusta mucho que ocupas los módulos que llevas desarrollando desde el semestre anterior en la clase de python. Es muy motivante calificar tareas tan bien hechas, muy buen trabajo sigue así 🥳 . Mi única sugerencia es que elimines los saltos de linea en el momento en que extraes tus secuencias, pues esto suele ser muy habitual en los archivos de secuencia. --- src/ADN_module.py | 274 ++++++++++++++++++++-------------------------- 1 file changed, 119 insertions(+), 155 deletions(-) diff --git a/src/ADN_module.py b/src/ADN_module.py index 193b277..8050a7c 100644 --- a/src/ADN_module.py +++ b/src/ADN_module.py @@ -1,165 +1,129 @@ -''' -Module name - ADN module - -Description - Modulo que contiene funciones que nos permiten trabajar con secuencias de ADN, contar y obtener - porcentajes de nucleotidos; obtener archivos en formato fasta, etc. +''' Name + ADN/ARN to protein Version - 1.0 - -Author - Lopez A. Brenda E. - -Functions - at_content - count_dna - delete_adapters - fasta_files - gc_content - nucleotide_percentage - + 1.5 + +Author + Lopez Angeles Brenda Elizabeth. + +Descripcion + Programa que convierte una secuencia de ADN o ARN en una secuencia peptidica. + Por default, el programa convierte secuencias de ARN. + +Category + Aminoacid sequence + +Usage + Python ARN_toPro.py [-h] [-f path/to/file] [-s SEQUENCE] [-o OUTPUT] [-p PRINT] [-c CHANGETODNA] + Python ARN_toPro.py -f data/ARN_protein.txt -o sata/output_peptid.txt -p + +Arguments + -h, --help + -f --file, --file path/to/file + -s SEQUENCE, --SEQUENCE + -o OUTPUT, --OUTPUT + -p PRINT, --PRINT + -c CHANCETODNA, --CHANGETODNA + +See also + None ''' -import re -def count_dna(dna): - ''' - Regresa el conteo de nucleotidos en una secuencia de ADN - Parameters: - adn (str): secuencia de ADN a procesar - Returns: - adn_count (list): lista que contiene cuenta de nucleotidos en el siguiente orden: (A, T, G, C) - ''' - dna_count = [] - dna_count.append(dna.upper().count('A')) - dna_count.append(dna.upper().count('T')) - dna_count.append(dna.upper().count('G')) - dna_count.append(dna.upper().count('C')) - return(dna_count) - -def at_content(pathfile, flag_round = 0): - ''' - Regresa la proporcion de AT en una secuencia de ADN - Parameters: - pathfile (str): ruta del archivo que contiene la cadena de ADN a procesar - flag_round (int): parametro opcional que permite redondear el resultado obtenido - Returns: - at_content (float): Proporcion de AT en la secuencia - ''' - with open(pathfile, "r") as seq_file: - my_dna = seq_file.read() - - length = len(my_dna) - a_count = my_dna.count('A') - t_count = my_dna.count('T') - - if flag_round: - at_content = round((a_count + t_count) / length, flag_round) - else: - at_content = ((a_count + t_count) / length) - - return(at_content) +# Importamos librerias +import argparse +from sys import flags +from aminoacids_module import evaluate_rna +from aminoacids_module import translate_dna +from ADN_module import evaluate_dna -def gc_content(pathfile, flag_round = 0): - ''' - Regresa la proporcion de GC en una secuencia de ADN - Parameters: - pathfile (str): ruta del archivo que contiene la cadena de ADN a procesar - flag_round (int): parametro opcional que permite redondear el resultado obtenido - Returns: - gc_content (float): Proporcion de GC en la secuencia - ''' - with open(pathfile, "r") as seq_file: - my_dna = seq_file.read() - - length = len(my_dna) - g_count = my_dna.count('G') - c_count = my_dna.count('C') - - if flag_round: - gc_content = round((g_count + c_count) / length, flag_round) +# Paso de argumentos mediante argparse +arg_parser = argparse.ArgumentParser(description="Translating ARN to protein") +arg_parser.add_argument("-f", "--FILE", + metavar="path/to/file", + help="Archivo con la secuencia de ARN o ADN", + required=False) + +arg_parser.add_argument("-s", "--SEQUENCE", + help="Secuencia de ARN o ADN", + type=str, + required=False) + +arg_parser.add_argument("-o", "--OUTPUT", + help="Archivo de salida", + required=False) + +arg_parser.add_argument("-p","--PRINT", + help = "Imprimir a pantalla la secuencia peptidica", + action = 'store_true', + required= False) + +arg_parser.add_argument("-c","--CHANGEtoDNA", + help = "Si la secuencia es de ADN", + action = 'store_true', + required= False) + +args = arg_parser.parse_args() + +# Abrimos el archivo y extraemos su contenido. +# Si el usuario ingresa una secuencia de ADN, la convertimos a ARN llamando a la funcion del modulo creado. + +if args.FILE: + with open(args.FILE, "r") as seq_file: + if args.CHANGEtoDNA: + ADN = seq_file.read().rstrip('\n').upper() + if evaluate_dna(ADN): + ARN = translate_dna(ADN) + else: + ARN = seq_file.read().rstrip('\n').upper() + +# Si el usurio ingresa una secuencia por teclado +# Si el usuario ingresa una secuencia de ADN, llamamos a la funcion translate_dna + +if args.SEQUENCE: + if args.CHANGEtoDNA: + ADN = args.SEQUENCE.rstrip('\n').upper() + ARN = translate_dna(ADN) else: - gc_content = ((g_count + c_count) / length) - - return(gc_content) + ARN = args.SEQUENCE.rstrip('\n').upper() -def nucleotide_percentage(filepath): - ''' - Obtiene el porcentaje de nucleotidos (AT y GC) en una secuencia de ADN - Parameters: - pathfile (str): ruta del archivo que contiene la cadena de ADN a procesar - Returns: - percentage (list): Lista que contiene el porcentage de aminoacidos en el siguiente orden: (AT, GC) - ''' - with open(filepath) as archivo: - secuencia_adn = archivo.read() - longitud_secuencia = len(secuencia_adn) - - percentage = [] - percentage_AT = ((secuencia_adn.count('A') + secuencia_adn.count('T')) * 100 )/(longitud_secuencia) - percentage_GC = (100 - percentage_AT) - percentage.append(percentage_AT) - percentage.append(percentage_GC) - - return(percentage) - -def delete_adapters(filepath_in, filepath_out = "data/file_adapters"): +def arn_to_peptid(ARN): ''' - Elimina adaptadores de una secuencia de ADN + Funcion que convierte una secuencia de ARN a proteina. + Si encuentra una secuencia con un codon incompleto, agregara un "*" Parameters: - pathfile_in (str): ruta del archivo que contiene la cadena de ADN a procesar - pathfile_out (str): ruta del archivo final en donde se escribiran las secuencias de ADN sin adaptadores + ARN (str): secuencia de ARN a procesar. Returns: - filepath_out (str): ruta del archivo final - ''' - with open(filepath_in,'r') as archivo: - secuencias= [line for line in archivo] - sin_adaptadores= [] - - for i in range(0,len(secuencias)): - sin_adaptadores.append(secuencias[i][14:]) - - my_file= open(filepath_out,'w') - my_file.write(''.join(sin_adaptadores)) - my_file.close() - return(filepath_out) - -def fasta_files(filepath_in, filepath_out = "data/fasta_file.fasta"): + peptide (str): secuencia peptidica generada. ''' - Genera un archivo con formato fasta. - Parameters: - filepath_in (str): ruta del archivo que contiene la secuencia de ADN - filepath_out (str): ruta del archivo final que contendra el formato fasta deseado - Returns: - filepath_out (str): ruta del archivo final - ''' - with open(filepath_in, 'r') as archivo: - secuencias = [line for line in archivo] - - format_seq = [secuencia[5:].upper().replace('-','') for secuencia in secuencias] - - my_file = open(filepath_out, 'w') - - for i in range(0,len(format_seq)): - my_file.write(" > seq_" + str(i+1) + "\n" + format_seq[i]) - my_file.close() - - return(filepath_out) - -def evaluate_dna(dna): - ''' - Evalua si el archivo contiene algun caracter diferente a los permitidos [ATGC]. - Parameters: - dna (str): secuencia de ADN a procesar. - Returns: - 0 (int): si encuentra caracteres invalidos. - 1 (int): si no encuentra caracteres invalidos. - ''' - not_dna = re.finditer("[^ATGC]+", dna) - matches = len([*re.finditer("[^ATGC]+", dna)]) - if matches: - for invalid in not_dna: - print(f"Existen caracteres invalidos: {invalid.group()} en las coordenadas: {invalid.span()}") - return(0) - else: - return(1) \ No newline at end of file + gencode = { + 'AUA':'I', 'AUC':'I', 'AUU':'I', 'AUG':'M', 'ACA':'T', + 'ACC':'T', 'ACG':'T', 'ACU':'T', 'AAC':'N', 'AAU':'N', + 'AAA':'K', 'AAG':'K', 'AGC':'S', 'AGU':'S', 'AGA':'R', + 'AGG':'R', 'CUA':'L', 'CUC':'L', 'CUG':'L', 'CUU':'L', + 'CCA':'P', 'CCC':'P', 'CCG':'P', 'CCU':'P', 'CAC':'H', + 'CAU':'H', 'CAA':'Q', 'CAG':'Q', 'CGA':'R', 'CGC':'R', + 'CGG':'R', 'CGU':'R', 'GUA':'V', 'GUC':'V', 'GUG':'V', + 'GUU':'V', 'GCA':'A', 'GCC':'A', 'GCG':'A', 'GCU':'A', + 'GAC':'D', 'GAU':'D', 'GAA':'E', 'GAG':'E', 'GGA':'G', + 'GGC':'G', 'GGG':'G', 'GGU':'G', 'UCA':'S', 'UCC':'S', + 'UCG':'S', 'UCU':'S', 'UUC':'F', 'UUU':'F', 'UUA':'L', + 'UUG':'L', 'UAC':'Y', 'UAU':'Y', 'UAA':'_', 'UAG':'_', + 'UGC':'C', 'UGU':'C', 'UGA':'_', 'UGG':'W'} + + codon_sequence = [ARN[i:i+3] for i in range(0,len(ARN),3)] + peptid = [gencode.get(codon, "*") for codon in codon_sequence] + return(peptid) + +# Evaluamos si la secuencia contiene algun caracter incorrecto. +# Si el usuario quiere un archivo como formato de salida. +# Si el usurio quiere imprimir la secuencia a pantalla. + +if evaluate_rna(ARN): + peptid = arn_to_peptid(ARN) + if args.OUTPUT: + output_file = open(args.OUTPUT,'w') + output_file.write(f"La secuencia proteica obtenida fue:\n{''.join(peptid)}") + output_file.close() + + if args.PRINT: + print(f"La secuencia proteica obtenida fue:\n{''.join(peptid)}")