Develop

data/ADN_at.txt

@@ -1 +1 @@
-gggggggggggggggg
+aaacccttjtaattiagogc

data/ARN_protein.txt

@@ -0,0 +1 @@
+AUGGCCAUGGCGCCCAGAACUGAGAUCAAUAGUACCCGUAUUAACGGGUGA

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
+

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

data/output_peptid.txt

@@ -0,0 +1,2 @@
+La secuencia proteica obtenida fue:
+MAMAPRTEINSTRING_

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 
+  ```
+
+

results/output_peptid.txt

@@ -0,0 +1,2 @@
+La secuencia proteica obtenida fue:
+MAMAPRTEINSTRING_

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)
-
+
+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)

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)}")

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))
+    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))

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")

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)