diff --git a/data/ADN_at.txt b/data/ADN_at.txt index 2bc758d..ab16b85 100644 --- a/data/ADN_at.txt +++ b/data/ADN_at.txt @@ -1 +1 @@ -gggggggggggggggg \ No newline at end of file +aaacccttjtaattiagogc \ No newline at end of file diff --git a/data/ARN_protein.txt b/data/ARN_protein.txt new file mode 100644 index 0000000..b5e8c83 --- /dev/null +++ b/data/ARN_protein.txt @@ -0,0 +1 @@ +AUGGCCAUGGCGCCCAGAACUGAGAUCAAUAGUACCCGUAUUAACGGGUGA \ No newline at end of file diff --git a/data/file1.txt b/data/file1.txt new file mode 100644 index 0000000..2c57307 --- /dev/null +++ b/data/file1.txt @@ -0,0 +1,23 @@ +#PDB id UniProt entry +3kip Q59Z17 +1n4w P12676 +6nms P78324 +3og2 Q70SY0 +1c17 P68699 +1otg Q05354 +1fjc P08199 +1mvf P0AE72 +5mvi Q8Z903 +4k7x B3D6W2 +1vb7 Q8R1G6 +1uhg P01012 +2nr4 Q8PVV4 +6av8 B3FIS6 +6nuc Q08209 +6vgo Q9H4B8 +2yrz P16144 +3plz O00482 +1tdz P42371 +3v9o Q2T1V0 +6liv P54769 + diff --git a/data/file2.txt b/data/file2.txt new file mode 100644 index 0000000..2dbdaa5 --- /dev/null +++ b/data/file2.txt @@ -0,0 +1,22 @@ +#Uniprot entry ENA id +Q59Z17 CP017624 +P12676 M31939 +P78324 D86043 +Q70SY0 AJ549427 +P68699 J01594 +Q05354 X53666 +P08199 M15825 +P0AE72 D16450 +Q8Z903 AL513382 +B3D6W2 CP000869 +Q8R1G6 BC024556 +P01012 V00383 +Q8PVV4 AE008384 +B3FIS6 EU195270 +Q08209 L14778 +Q9H4B8 AJ291679 +P16144 X51841 +O00482 U80251 +P42371 X74298 +Q2T1V0 CP000086 +P54769 U08598 diff --git a/data/output_peptid.txt b/data/output_peptid.txt new file mode 100644 index 0000000..d63c607 --- /dev/null +++ b/data/output_peptid.txt @@ -0,0 +1,2 @@ +La secuencia proteica obtenida fue: +MAMAPRTEINSTRING_ \ No newline at end of file diff --git a/docs/Diccionarios.md b/docs/Diccionarios.md new file mode 100644 index 0000000..0391b1f --- /dev/null +++ b/docs/Diccionarios.md @@ -0,0 +1,60 @@ +# Diccionarios + +Para crear un diccionario en python: + +- Se crea por medio de llaves, declarando cuales serán las llaves (keys) las cuales deben de ser únicas. + + ``` + enzymes = { + 'EcoRI': r'GAATT', + 'AvaII': r'GGCC' + } + + Enzymes={} + + # Métodos + + #Elimina un elemento de un diccionario + enzymes.pop('EcoRI') + + # Obtener elementos dentro de un diccionario: + all_counts["key"] + # Si esperamos que el elemento no se encuentra en el diccionario, entonces, podemos hacer que nos devuelva un 0. + all_counts.get('TC',0) + + # Para obtener las llaves + all_counts.keys() + + # Función sort + sort(variable) + + # Metodo items: regresa tuplas, las llaves y el valor + all_counts.items() + + # Ya que genera tuplas, entonces podemos iterar sobre ambos elementos. + for key, item in all_counts.items: + Print(key) + print(item) + + # fromkeys: inicializar un diccionario con valores e iterables: listas, tuplas, etc. + llaves = [a,b,c,d] + diccionario = dict.fromkeys(llaves,[]) + {'a':[],'b':[],...} + + # Por el contrario: + llaves = [a,b,c,d] + valores =[1,2,3] + diccionario = dict.fromkeys(llaves,valores) + {'a':[1,2,3],'b':[1,2,3],...} + + # Popitem: borra el ultimo par clave-valor insertado. + diccionario.popitem() + + # setdefault: inserta un elemento al final del diccionario si es que este no fue encontrado y se asigna un valor "none" + diccionario.setdefault("peso") + + # Values + Accede a los valores + ``` + + \ No newline at end of file diff --git a/results/output_peptid.txt b/results/output_peptid.txt new file mode 100644 index 0000000..d63c607 --- /dev/null +++ b/results/output_peptid.txt @@ -0,0 +1,2 @@ +La secuencia proteica obtenida fue: +MAMAPRTEINSTRING_ \ No newline at end of file diff --git a/src/ADN_module.py b/src/ADN_module.py index 5b2fba2..193b277 100644 --- a/src/ADN_module.py +++ b/src/ADN_module.py @@ -21,7 +21,7 @@ nucleotide_percentage ''' - +import re def count_dna(dna): ''' Regresa el conteo de nucleotidos en una secuencia de ADN @@ -145,4 +145,21 @@ def fasta_files(filepath_in, filepath_out = "data/fasta_file.fasta"): my_file.close() return(filepath_out) - \ No newline at end of file + +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 diff --git a/src/ARN_toPro.py b/src/ARN_toPro.py new file mode 100644 index 0000000..4cec412 --- /dev/null +++ b/src/ARN_toPro.py @@ -0,0 +1,129 @@ +''' Name + ADN/ARN to protein + +Version + 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 +''' +# 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 + +# 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().upper() + if evaluate_dna(ADN): + ARN = translate_dna(ADN) + else: + ARN = seq_file.read().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.upper() + ARN = translate_dna(ADN) + else: + ARN = args.SEQUENCE.upper() + +def arn_to_peptid(ARN): + ''' + Funcion que convierte una secuencia de ARN a proteina. + Si encuentra una secuencia con un codon incompleto, agregara un "*" + Parameters: + ARN (str): secuencia de ARN a procesar. + Returns: + peptide (str): secuencia peptidica generada. + ''' + 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)}") \ No newline at end of file diff --git a/src/aminoacids_module.py b/src/aminoacids_module.py index 92a899c..bed4382 100644 --- a/src/aminoacids_module.py +++ b/src/aminoacids_module.py @@ -16,7 +16,7 @@ aminoacid_per ''' - +import re def aminoacid_per(aminoacid_sequence, aminoacid_list = ['A','I','L','M','F','W','Y','V']): ''' Calcula el porcentaje de aminoacidos en una seuencia @@ -111,4 +111,45 @@ def traducction(secuencia): # STOP if codon == 'UAA' or codon == 'UGA' or codon == 'UAG': peptid.append('-STOP-') - return("".join(peptid)) \ No newline at end of file + return("".join(peptid)) + +def evaluate_rna(rna): + ''' + Evalua si el archivo contiene algun caracter diferente a los permitidos [AUGC]. + Parameters: + dna (str): secuencia de ARN a procesar. + Returns: + 0 (int): si encuentra caracteres invalidos. + 1 (int): si no encuentra caracteres invalidos. + ''' + not_dna = re.finditer("[^AUGC]+", rna) + matches = len([*re.finditer("[^AUGC]+", rna)]) + if matches: + for invalid in not_dna: + print(f"Existen caracteres invalidos: {invalid.group()} en las coordenadas: {invalid.span()}") + return(0) + else: + return(1) + +def codon_format(ARN): + ''' + Da formato de codones a una secuencia de ARN. + Parameters: + ARN (str): secuencia de ARN a formatear. + Returns: + codon_seq (list): lista con los codones de la secuencia. + ''' + codon_seq = [ARN[i:i+3] for i in range(0,len(ARN),3)] + return(codon_seq) + +def translate_dna(ADN): + ''' + Convierte una secuencia de ADN a ARN. + Parameters: + ADN (str): secuencia de ADN a traducir. + Returns: + ARN_seq (str): secuencia de ARN. + ''' + ARN_dic = {'A' : 'U','T' : 'A','C' : 'G','G' : 'C'} + ARN_seq = [ARN_dic.get(nucleotide) for nucleotide in ADN] + return(''.join(ARN_seq)) \ No newline at end of file diff --git a/src/diccionario.py b/src/diccionario.py new file mode 100644 index 0000000..fb2768c --- /dev/null +++ b/src/diccionario.py @@ -0,0 +1,19 @@ +# Diccionarios + +cadena=[] +cadena= input("Introduce el texto que desees, no mas de 10000 letras \n") + +lista=cadena.split(' ') +diccionario={} +sinEspacios= cadena.replace(" ","") + +if len(sinEspacios) <= 10000: + for word in lista: + cuenta= lista.count(word) + diccionario[word]= cuenta + + for word, valor in diccionario.items(): + print(word, end=' '), + print(valor) +else: + print("El texto no debe contener más de 10000 letras") \ No newline at end of file diff --git a/src/ejercicio.py b/src/ejercicio.py new file mode 100644 index 0000000..acc5e97 --- /dev/null +++ b/src/ejercicio.py @@ -0,0 +1,13 @@ +file1 = 'data/file1.txt' +file2 = 'data/file2.txt' +with open(file1, "r") as fistfile: + content = fistfile.read().split('\n') + +fisrtfile_list = [elements.split('\t') for elements in content] + +with open(file2, "r") as secondfile: + content = secondfile.read().replace(' ','\t').split('\n') +#print(content) +secondfile_list = [elements.split('\t') for elements in content] + +print(secondfile_list) diff --git a/src/rich_at.py b/src/rich_at.py index e381036..5faf74d 100644 --- a/src/rich_at.py +++ b/src/rich_at.py @@ -5,7 +5,7 @@ 1.0 Author - Lopez Angeles Brenda E. + Lopez Angeles Brenda Elizabeth. Descripcion Programa que busca regiones ricas en AT @@ -14,21 +14,24 @@ DNA sequence Usage - Python rich_at.py -f path/to/file [-s ] - py .\src\rich_at.py -f data/ADN_at.txt -s 4 + Python .\src\rich_at.py [-h] -f path/to/file [-s SEARCH] + python .\src\rich_at.py -f data/ADN_at.txt -s 4 Arguments - -h --help - -f --file - -s --search + -h, --help + -f --file, --file path/to/file + Archivo con secuencia de ADN + -s SEARCH, --search SEARCH + Tamaño minimo de las regiones de AT See also None ''' - +# Importamos librerias import argparse import re +# Paso de argumentos mediante argparse arg_parser = argparse.ArgumentParser(description="Search AT rich regions") arg_parser.add_argument("-f", "--file", metavar="path/to/file", @@ -36,36 +39,58 @@ required=True) arg_parser.add_argument("-s", "--search", - help="cantidad minima de AT a buscar", + help="Tamaño minimo de las regiones de AT", type=int, required=False) args = arg_parser.parse_args() +# Abrimos el archivo y extraemos su contenido with open(args.file, "r") as seq_file: dna = seq_file.read().upper() - + def evaluate(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 en tu archivo: {invalid.group()} en las coordenadas: {invalid.span()}") + print(f"Existen caracteres invalidos en el archivo: {invalid.group()} en las coordenadas: {invalid.span()}") return(0) else: return(1) def find_regions(dna, at=2): - at_rich = re.finditer("A+|T+",dna) + ''' + Evalua la existencia de regiones ricas en AT en una cadena de ADN. + Parameters: + dna (str): secuencia de ADN a procesar. + at (int): tamaño minimo de las regiones ricas en AT a buscar, por default 2. + Returns: + 0 (int): Termina la evaluacion de la secuencia. + ''' + at_rich = re.finditer("[AT]+",dna) matches = len([*re.finditer("A+|T+", dna)]) if matches: + count_at = 0 for islas in at_rich: if len(islas.group()) >= at: + count_at += 1 print(f"Se encontro esta region rica en AT: {islas.group()} en la posicion {islas.span()}") + if not count_at: + print(f"No se encontraron regiones ricas en AT = {at}") else: print("No se encontraron regiones ricas en AT") return(0) +# Llamamos a nuestras funciones. if evaluate(dna): if args.search: ans = find_regions(dna,args.search)