From e26a489fea200ae06170047f72930c081f7e7622 Mon Sep 17 00:00:00 2001 From: ricardofoliveira61 <153216922+ricardofoliveira61@users.noreply.github.com> Date: Wed, 24 Jan 2024 04:03:56 +0000 Subject: [PATCH] Delete Test_nw.ipynb --- Test_nw.ipynb | 913 -------------------------------------------------- 1 file changed, 913 deletions(-) delete mode 100644 Test_nw.ipynb diff --git a/Test_nw.ipynb b/Test_nw.ipynb deleted file mode 100644 index 825c4b1..0000000 --- a/Test_nw.ipynb +++ /dev/null @@ -1,913 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 99, - "metadata": {}, - "outputs": [], - "source": [ - "# criamos funçoes validar \n", - "# modificamos asserts no nw\n", - "# verificar lista aminoacidos\n", - "\n", - "\n", - "def validar_dna(seq:str)->bool:\n", - " assert type(seq)==str,'A sequência não foi fornecida em formato de string'\n", - " lista_nucleotidos = ['A','C','T','G']\n", - " for base in seq.upper():\n", - " if base not in lista_nucleotidos:\n", - " return False\n", - " \n", - " return True\n", - "\n", - "def validar_rna(seq:str)->bool:\n", - " assert type(seq)==str,'A sequência não foi fornecida em formato de string'\n", - " lista_nucleotidos = ['A','C','U','G']\n", - " for base in seq.upper():\n", - " if base not in lista_nucleotidos:\n", - " return False\n", - " \n", - " return True\n", - "\n", - "\n", - "def validar_prot(seq:str)->bool:\n", - " assert type(seq)==str,'A sequência não foi fornecida em formato de string'\n", - " lista_aminoacidos = ['A','C','D','E','F','G','H','I','K','L','M','N','P','Q','R','S','T','V','W','Y','_']\n", - " for aa in seq.upper():\n", - " if aa not in lista_aminoacidos:\n", - " return False\n", - " \n", - " return True\n", - "\n", - "def formatar(x):\n", - " if type(x) is int:\n", - " return f\"{x:>3d}\"\n", - " else:\n", - " return f\"{x:>3}\"\n", - " \n", - "def print_matrix(S1,S2,M):\n", - " \n", - " print(*list(\" \" + S1), sep=\" \")\n", - " for x2, L in zip(S2,M): #x2 caracter que vem da string S2\n", - " LL=[formatar(x) for x in L]\n", - " print(x2,*LL)\n", - " print()\n", - "\n", - "def score_sub_acid_nuc(x1:str,x2:str,match,mismatch)->int:\n", - " if x1==x2:return match\n", - " else: return mismatch\n", - "\n", - "def score_subst_prot(nome_matriz:str, aa1:str, aa2:str) -> int:\n", - " \"\"\"\n", - " Esta função abre e lê um destes ficheiros de texto: \"BLOSSOM62.txt\", \"BLOSSOM80.txt\", \"PAM30.txt\", \"PAM70.txt\" \n", - " retirando a matriz de substituição do ficheiro como uma matriz bidimensional.\n", - " Depois navega na matriz de substituição obtida e retorna o score correspondente ao ????alinhamento???? de dois dos seguintes caracteres: \n", - " 'A','R','N','D','C','Q','E','G','H','I','L','K','M','F','P','S','T','W','Y','V','B','J','Z','X','_',\n", - " sendo que as letras representam os aminoácidos e o caracter '_' representa o codão stop.\n", - " \n", - " Parameters\n", - " ----------\n", - " nome_matriz:str\n", - " Nome da matriz de substituição que se pretende que seja lida e utilizada para fornecer os scores de substituição\n", - "\n", - " aa1:str\n", - " Aminoácido que vai ser procurado ao longo da primeira coluna da matriz de substituição\n", - "\n", - " aa2:str\n", - " Aminoácido que vai ser procurado ao longo da primeira linha da matriz de substituição\n", - "\n", - " Returns\n", - " -------\n", - " score:int\n", - " Score obtido para o alinhamento dos dois aminoácidos na matriz de substituição\n", - "\n", - " Raises\n", - " ------\n", - " AssertionError\n", - " Quando o nome da matriz fornecido não corresponde a uma das matrizes aceites pela função:\n", - " \"BLOSSOM62\", \"BLOSSOM80\", \"PAM30\", \"PAM70\"\n", - "\n", - " AssertionError\n", - " Quando o caracter inserido correspondente ao 'aa1' não é válido como aminoácido ou codão stop\n", - "\n", - " AssertionError\n", - " Quando o caracter inserido correspondente ao 'aa2' não é válido como aminoácido ou codão stop\n", - " \"\"\"\n", - " assert nome_matriz.upper() in [\"BLOSSOM62\", \"BLOSSOM80\", \"PAM30\", \"PAM70\"],\"A matriz de substituição escolhida é inválida, apenas aceita as matrizes 'BLOSSOM62', 'BLOSSOM80', 'PAM30', 'PAM70'\"\n", - " with open(nome_matriz.upper()+\".txt\", \"r\") as file:\n", - " matriz = []\n", - " for line in file:\n", - " line = line.strip()\n", - " linha = []\n", - " valor = \"\"\n", - " for elem in line:\n", - " if elem == \" \":\n", - " if len(valor) != 0:\n", - " linha.append(valor)\n", - " valor = \"\"\n", - " else:\n", - " valor += elem\n", - " linha.append(valor)\n", - " matriz.append(linha)\n", - " aa1, aa2 = aa1.upper(), aa2.upper()\n", - " lista_aminoacidos = ['A','R','N','D','C','Q','E','G','H','I','L','K','M','F','P','S','T','W','Y','V','B','J','Z','X','_']\n", - " assert aa1 in lista_aminoacidos,f\"O caracter {aa1} não é válido como aminoácido ou codão stop\"\n", - " assert aa2 in lista_aminoacidos,f\"O caracter {aa2} não é válido como aminoácido ou codão stop\"\n", - " coluna, linha = 0, 0\n", - " for i in range(1,len(matriz)):\n", - " if aa1 == matriz[i][0]:\n", - " linha = i\n", - " break\n", - " for pos, elem in enumerate(matriz[0]):\n", - " if elem == aa2:\n", - " coluna = pos\n", - " break\n", - " score = matriz[linha][coluna]\n", - " return int(score)\n", - "\n", - "def reconstrucao(seq1,seq2,trace):\n", - " aligned_seq1 = ''\n", - " aligned_seq2 = ''\n", - " linha=len(seq1)-1\n", - " coluna=len(seq2)-1\n", - "\n", - " while trace[linha][coluna]!=0:\n", - " if trace[linha][coluna] == '↖':\n", - " aligned_seq1 = seq1[linha] + aligned_seq1\n", - " aligned_seq2 = seq2[coluna] + aligned_seq2\n", - " linha -= 1\n", - " coluna -= 1\n", - " elif trace[linha][coluna] == '↑':\n", - " aligned_seq1 = seq1[linha] + aligned_seq1\n", - " aligned_seq2 = '-' + aligned_seq2\n", - " linha -= 1\n", - " elif trace[linha][coluna] == '←':\n", - " aligned_seq1 = '-' + aligned_seq1\n", - " aligned_seq2 = seq2[coluna] + aligned_seq2\n", - " coluna-= 1\n", - " print(aligned_seq1,aligned_seq2,sep='\\n')\n", - " return (aligned_seq1,aligned_seq2)\n", - "\n", - "def needleman_wunsch(seq1:str,seq2:str,seq_tipo:str,gap:int=-4,matriz:str='Blossom62',match:int=2,mismatch:int=-1,matrizes=True ):\n", - " \"\"\"\n", - " Realiza o alinhamento global de duas sequências recorrendo o algoritmo Needleman-Wunsch.\n", - "\n", - " Parameters\n", - " ----------\n", - " seq1 : str\n", - " Primeira sequência\n", - " seq2 : str\n", - " Segunda sequência\n", - "\n", - " seq_tipo: str\n", - " Identifica o tipo das sequências que se pretende alinhar\n", - "\n", - " gap: int\n", - " Valor a utilizar para penalizar os espaçamentos. Por padrão considera-se o valor de penalização como -4\n", - "\n", - " matriz: str\n", - " Matriz de substituição de aminoacidos a utilizar para realizar o alinhamento de proteínas\n", - "\n", - " match: int\n", - " Valor a utilizar para quando as duas bases nucleicas são iguais. Por default é 2. Apenas para o alinhamento de DNA/RNA\n", - "\n", - " mismatch: int\n", - " Valor a utilizar para quando as duas bases nucleicas são diferentes. Por default é -1. Apenas para o alinhamento de DNA/RNA\n", - "\n", - " matrizes: bool\n", - " Indica \n", - "\n", - " Returns\n", - " ----------\n", - " Tuple\n", - " devolve um tuplo com a matriz de pontuação, a matriz de rastreamento e o alinhamento ótimo\n", - " \n", - " \"\"\"\n", - " assert seq_tipo.upper() in ['DNA','RNA','PROTEIN'], 'O tipo de sequência fornecido não é valido, apenas pode assumir o valor de DNA, RNA ou protein'\n", - " \n", - " if seq_tipo.upper()=='DNA': \n", - " assert validar_dna(seq1),'A sequencia 1 não é DNA'\n", - " assert validar_dna(seq2),'A sequencia 2 não é DNA' \n", - "\n", - " elif seq_tipo.upper()=='RNA':\n", - " assert validar_rna(seq1),'A sequencia 1 não é RNA'\n", - " assert validar_rna(seq2),'A sequencia 2 não é RNA'\n", - "\n", - " else:\n", - " assert validar_prot(seq1), 'A sequencia 1 não é uma proteina'\n", - " assert validar_prot(seq2), 'A sequencia 2 não é uma proteina'\n", - "\n", - " if seq1 == \"\" or seq2 == \"\":\n", - " raise TypeError(\"A sequência fornecida não pode ser uma string vazia\")\n", - "\n", - "\n", - " seq1='-'+seq1\n", - " seq2='-'+seq2\n", - " nrows = len(seq1)\n", - " ncols = len(seq2)\n", - "\n", - " score_matrix=[[0]*ncols for linhas in range(nrows)] # iniciar a matriz score apenas com 0\n", - " score_matrix[0]=[c*gap for c in range(ncols)] #prenchimento da primeira linha da matriz score\n", - " for linha in range(1, nrows):score_matrix[linha][0] = linha * gap # preenchimento da primeira coluna da matriz score\n", - "\n", - " traceback_matrix = [[0] * ncols for linhas in range(nrows)] # iniciar a matriz traceback com 0\n", - " traceback_matrix[0] =[0 if col==0 else '←' for col in range(ncols)] # prenchimento da primeira linha da matriz traceback\n", - " for linha in range(1,nrows): traceback_matrix[linha][0]='↑' # preenchimento da primeira coluna da matriz traceback\n", - "\n", - " if seq_tipo.upper()=='DNA' or seq_tipo.upper()=='RNA': #alinhamento de acidos nucleicos\n", - " for linha in range(1, nrows):\n", - " for coluna in range(1, ncols):\n", - " diagonal = score_matrix[linha - 1][coluna - 1] + score_sub_acid_nuc(seq1[linha],seq2[coluna],match,mismatch)\n", - " cima = score_matrix[linha - 1][coluna] + gap\n", - " esquerda = score_matrix[linha][coluna - 1] + gap\n", - "\n", - " max_score = max(diagonal, esquerda, cima)\n", - " score_matrix[linha][coluna] = max_score\n", - "\n", - " if max_score == diagonal: traceback_matrix[linha][coluna] = '↖'\n", - " elif max_score == cima: traceback_matrix[linha][coluna] = '↑'\n", - " elif max_score == esquerda: traceback_matrix[linha][coluna] = '←'\n", - "\n", - " else: # alinhamento de proteinas\n", - " for linha in range(1, nrows):\n", - " for coluna in range(1, ncols):\n", - " diagonal = score_matrix[linha - 1][coluna - 1] + score_subst_prot(matriz,seq1[linha],seq2[coluna])\n", - " cima = score_matrix[linha - 1][coluna] + gap\n", - " esquerda = score_matrix[linha][coluna - 1] + gap\n", - "\n", - " max_score = max(diagonal, esquerda, cima)\n", - " score_matrix[linha][coluna] = max_score\n", - "\n", - " if max_score == diagonal: traceback_matrix[linha][coluna] = '↖'\n", - " elif max_score == cima: traceback_matrix[linha][coluna] = '↑'\n", - " elif max_score == esquerda: traceback_matrix[linha][coluna] = '←'\n", - "\n", - " if matrizes:\n", - " print(\"Matriz de Pontuação:\")\n", - " print_matrix(seq2,seq1,score_matrix)\n", - " print(\"Matriz de Rastreamento:\")\n", - " print_matrix(seq2,seq1,traceback_matrix)\n", - " return score_matrix[-1][-1],reconstrucao(seq1,seq2,traceback_matrix)\n", - " \n", - " else:\n", - " return score_matrix[-1][-1],reconstrucao(seq1,seq2,traceback_matrix)" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "metadata": {}, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'BLOSSOM62.txt'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[100], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;66;03m# exemplo de alinhamento de DNA\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[43mneedleman_wunsch\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mPHSWG\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mHGWAG\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mPROTEIN\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[1;32mIn[99], line 226\u001b[0m, in \u001b[0;36mneedleman_wunsch\u001b[1;34m(seq1, seq2, seq_tipo, gap, matriz, match, mismatch, matrizes)\u001b[0m\n\u001b[0;32m 224\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m linha \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, nrows):\n\u001b[0;32m 225\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m coluna \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m1\u001b[39m, ncols):\n\u001b[1;32m--> 226\u001b[0m diagonal \u001b[38;5;241m=\u001b[39m score_matrix[linha \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m][coluna \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m+\u001b[39m \u001b[43mscore_subst_prot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmatriz\u001b[49m\u001b[43m,\u001b[49m\u001b[43mseq1\u001b[49m\u001b[43m[\u001b[49m\u001b[43mlinha\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43mseq2\u001b[49m\u001b[43m[\u001b[49m\u001b[43mcoluna\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 227\u001b[0m cima \u001b[38;5;241m=\u001b[39m score_matrix[linha \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m][coluna] \u001b[38;5;241m+\u001b[39m gap\n\u001b[0;32m 228\u001b[0m esquerda \u001b[38;5;241m=\u001b[39m score_matrix[linha][coluna \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m+\u001b[39m gap\n", - "Cell \u001b[1;32mIn[99], line 89\u001b[0m, in \u001b[0;36mscore_subst_prot\u001b[1;34m(nome_matriz, aa1, aa2)\u001b[0m\n\u001b[0;32m 53\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 54\u001b[0m \u001b[38;5;124;03mEsta função abre e lê um destes ficheiros de texto: \"BLOSSOM62.txt\", \"BLOSSOM80.txt\", \"PAM30.txt\", \"PAM70.txt\" \u001b[39;00m\n\u001b[0;32m 55\u001b[0m \u001b[38;5;124;03mretirando a matriz de substituição do ficheiro como uma matriz bidimensional.\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 86\u001b[0m \u001b[38;5;124;03m Quando o caracter inserido correspondente ao 'aa2' não é válido como aminoácido ou codão stop\u001b[39;00m\n\u001b[0;32m 87\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 88\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m nome_matriz\u001b[38;5;241m.\u001b[39mupper() \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBLOSSOM62\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBLOSSOM80\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPAM30\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mPAM70\u001b[39m\u001b[38;5;124m\"\u001b[39m],\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mA matriz de substituição escolhida é inválida, apenas aceita as matrizes \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mBLOSSOM62\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mBLOSSOM80\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPAM30\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPAM70\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m---> 89\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mnome_matriz\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mupper\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m.txt\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mr\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m file:\n\u001b[0;32m 90\u001b[0m matriz \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m 91\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m line \u001b[38;5;129;01min\u001b[39;00m file:\n", - "File \u001b[1;32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.11_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python311\\site-packages\\IPython\\core\\interactiveshell.py:310\u001b[0m, in \u001b[0;36m_modified_open\u001b[1;34m(file, *args, **kwargs)\u001b[0m\n\u001b[0;32m 303\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01min\u001b[39;00m {\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m}:\n\u001b[0;32m 304\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m 305\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIPython won\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt let you open fd=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m by default \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 306\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 307\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myou can use builtins\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m open.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 308\u001b[0m )\n\u001b[1;32m--> 310\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mio_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'BLOSSOM62.txt'" - ] - } - ], - "source": [ - "# exemplo de alinhamento de DNA\n", - "needleman_wunsch(\"PHSWG\",\"HGWAG\",\"PROTEIN\")" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_matriz_correta (__main__.Testneedlemanwunch.test_matriz_correta) ... ok\n", - "test_matriz_errada (__main__.Testneedlemanwunch.test_matriz_errada) ... ok\n", - "test_needleman_wunsch_letras_maiusculas (__main__.Testneedlemanwunch.test_needleman_wunsch_letras_maiusculas) ... ok\n", - "test_needleman_wunsch_letras_minusculas (__main__.Testneedlemanwunch.test_needleman_wunsch_letras_minusculas) ... ok\n", - "test_nw_caracter_seq1_DNA_errado (__main__.Testneedlemanwunch.test_nw_caracter_seq1_DNA_errado) ... ok\n", - "test_nw_caracter_seq1_PROTEINA_errado (__main__.Testneedlemanwunch.test_nw_caracter_seq1_PROTEINA_errado) ... ok\n", - "test_nw_caracter_seq1_RNA_errado (__main__.Testneedlemanwunch.test_nw_caracter_seq1_RNA_errado) ... ok\n", - "test_nw_caracter_seq2_DNA_errado (__main__.Testneedlemanwunch.test_nw_caracter_seq2_DNA_errado) ... ok\n", - "test_nw_caracter_seq2_PROTEINA_errado (__main__.Testneedlemanwunch.test_nw_caracter_seq2_PROTEINA_errado) ... ok\n", - "test_nw_caracter_seq2_RNA_errado (__main__.Testneedlemanwunch.test_nw_caracter_seq2_RNA_errado) ... ok\n", - "test_nw_seq1_not_dna (__main__.Testneedlemanwunch.test_nw_seq1_not_dna) ... ok\n", - "test_nw_seq1_not_rna (__main__.Testneedlemanwunch.test_nw_seq1_not_rna) ... ok\n", - "test_nw_seq2_not_dna (__main__.Testneedlemanwunch.test_nw_seq2_not_dna) ... ok\n", - "test_nw_seq2_not_rna (__main__.Testneedlemanwunch.test_nw_seq2_not_rna) ... ok\n", - "test_nw_seq_tipo_caracter_errado_DNA (__main__.Testneedlemanwunch.test_nw_seq_tipo_caracter_errado_DNA) ... ok\n", - "test_nw_seq_tipo_caracter_errado_PROTEIN (__main__.Testneedlemanwunch.test_nw_seq_tipo_caracter_errado_PROTEIN) ... ok\n", - "test_nw_seq_tipo_caracter_errado_RNA (__main__.Testneedlemanwunch.test_nw_seq_tipo_caracter_errado_RNA) ... ok\n", - "test_seq1_vazio (__main__.Testneedlemanwunch.test_seq1_vazio) ... ok\n", - "test_seq2_vazio (__main__.Testneedlemanwunch.test_seq2_vazio) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 19 tests in 0.023s\n", - "\n", - "OK\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Matriz de Pontuação:\n", - " - A G A\n", - "- 0 -4 -8 -12\n", - "A -4 2 -2 -6\n", - "C -8 -2 1 -3\n", - "T -12 -6 -3 0\n", - "\n", - "Matriz de Rastreamento:\n", - " - A G A\n", - "- 0 ← ← ←\n", - "A ↑ ↖ ← ↖\n", - "C ↑ ↑ ↖ ↖\n", - "T ↑ ↑ ↖ ↖\n", - "\n", - "ACT\n", - "AGA\n", - "Matriz de Pontuação:\n", - " - A G A\n", - "- 0 -4 -8 -12\n", - "A -4 2 -2 -6\n", - "C -8 -2 1 -3\n", - "T -12 -6 -3 0\n", - "\n", - "Matriz de Rastreamento:\n", - " - A G A\n", - "- 0 ← ← ←\n", - "A ↑ ↖ ← ↖\n", - "C ↑ ↑ ↖ ↖\n", - "T ↑ ↑ ↖ ↖\n", - "\n", - "ACT\n", - "AGA\n", - "Matriz de Pontuação:\n", - " - A G A\n", - "- 0 -4 -8 -12\n", - "A -4 2 -2 -6\n", - "C -8 -2 1 -3\n", - "T -12 -6 -3 0\n", - "G -16 -10 -4 -4\n", - "G -20 -14 -8 -5\n", - "\n", - "Matriz de Rastreamento:\n", - " - A G A\n", - "- 0 ← ← ←\n", - "A ↑ ↖ ← ↖\n", - "C ↑ ↑ ↖ ↖\n", - "T ↑ ↑ ↖ ↖\n", - "G ↑ ↑ ↖ ↖\n", - "G ↑ ↑ ↖ ↖\n", - "\n", - "ACTGG\n", - "A--GA\n", - "Matriz de Pontuação:\n", - " - a g a\n", - "- 0 -4 -8 -12\n", - "a -4 2 -2 -6\n", - "c -8 -2 1 -3\n", - "t -12 -6 -3 0\n", - "g -16 -10 -4 -4\n", - "g -20 -14 -8 -5\n", - "\n", - "Matriz de Rastreamento:\n", - " - a g a\n", - "- 0 ← ← ←\n", - "a ↑ ↖ ← ↖\n", - "c ↑ ↑ ↖ ↖\n", - "t ↑ ↑ ↖ ↖\n", - "g ↑ ↑ ↖ ↖\n", - "g ↑ ↑ ↖ ↖\n", - "\n", - "actgg\n", - "a--ga\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from contextlib import AbstractContextManager\n", - "from typing import Any\n", - "import unittest\n", - "\n", - "class Testneedlemanwunch(unittest.TestCase):\n", - " def test_nw_seq_tipo_caracter_errado_DNA(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\", \"AGA\",\"DNA/\") \n", - " \n", - " def test_nw_seq_tipo_caracter_errado_RNA(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"AUA\",\"RNA/\")\n", - " \n", - " def test_nw_seq_tipo_caracter_errado_PROTEIN(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"CREATINNA\", \"BEEFFAA\",\"/PROTEIN\") \n", - " \n", - " def test_nw_caracter_seq1_DNA_errado(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG-\", \"AGA\",\"DNA\")\n", - "\n", - " def test_nw_caracter_seq2_DNA_errado(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\", \"AGA%\",\"DNA\")\n", - "\n", - " def test_nw_caracter_seq1_RNA_errado(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG-\", \"AUA\",\"RNA\")\n", - "\n", - " def test_nw_caracter_seq2_RNA_errado(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"AUA/\",\"RNA\")\n", - "\n", - " def test_nw_caracter_seq1_PROTEINA_errado(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"CREATINNA%\", \"BEEFFAA\",\"PROTEIN\")\n", - "\n", - " def test_nw_caracter_seq2_PROTEINA_errado(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"CREATINNA\", \"BEEFFAA%/\",\"PROTEIN\")\n", - " \n", - " def test_nw_seq1_not_dna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"AGA\",\"DNA\")\n", - " \n", - " def test_nw_seq2_not_dna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"AUA\",\"DNA\")\n", - " \n", - " def test_nw_seq1_not_rna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACTGG\", \"AUA\",\"RNA\")\n", - " \n", - " def test_nw_seq2_not_rna(self):\n", - " with self.assertRaises(AssertionError):\n", - " needleman_wunsch(\"ACUGG\", \"ATA\",\"RNA\")\n", - " \n", - " def test_seq1_vazio(self):\n", - " with self.assertRaises(TypeError):\n", - " needleman_wunsch(\"\", \"ATA\",\"DNA\")\n", - "\n", - " def test_seq2_vazio(self):\n", - " with self.assertRaises(TypeError):\n", - " needleman_wunsch(\"ACTGG\",\"\",\"DNA\")\n", - "\n", - " def test_needleman_wunsch_letras_maiusculas(self):\n", - " score, _ = needleman_wunsch(\"ACTGG\", \"AGA\", \"DNA\")\n", - " self.assertEqual(score, -5)\n", - "\n", - " def test_needleman_wunsch_letras_minusculas(self):\n", - " score, _ = needleman_wunsch(\"actgg\", \"aga\", \"dna\")\n", - " self.assertEqual(score, -5)\n", - "\n", - " def test_alinhamento_DNA_correto(self):\n", - " self.assertEqual(needleman_wunsch(\"AGATT\",\"ACTA\",\"DNA\"),(-2, ('AGATT', 'A-CTA')))\n", - "\n", - " def test_alinhamento_RNA_correto(self):\n", - " self.assertEqual(needleman_wunsch(\"UACAA\",\"AGAU\",\"RNA\"),(-2, ('UACAA', '-AGAU')))\n", - " \n", - " def test_alinhamento_PROTEIN_correto(self):\n", - " self.assertEqual(needleman_wunsch(\"AUC\",\"FUADCD\",\"PROTEIN\"),(, ('AUC', 'FUADCD')))\n", - "\n", - "suite = unittest.TestLoader().loadTestsFromTestCase(Testneedlemanwunch)\n", - "unittest.TextTestRunner(verbosity=3).run(suite)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# TESTE MOTIFS" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "metadata": {}, - "outputs": [], - "source": [ - "def alfabeto(tipo_seq:str)->str:\n", - " '''\n", - " Esta função recebe o tipo de uma sequência e devolve o seu respetivo alfabeto\n", - "\n", - " Parameters\n", - " ---------\n", - " tipo_seq:str\n", - " Tipo válido de uma sequência biológica. Pode assumir os valores de DNA, RNA, protein,\n", - " proteína ou prot\n", - "\n", - " Returns\n", - " -------\n", - " list(str)\n", - " Composto pelo tipo de sequência e o seu respetivo alfabeto\n", - " \n", - " Raises\n", - " ------\n", - " ValueError\n", - " Quando o tipo de sequência fornecido não é um tipo de sequência biológica válida\n", - " '''\n", - " from unidecode import unidecode\n", - " if tipo_seq.upper()==\"DNA\":\n", - " DNA=\"ACGT\"\n", - " return [tipo_seq.upper(),DNA]\n", - " elif tipo_seq.upper()==\"RNA\":\n", - " RNA=\"ACGU\"\n", - " return [tipo_seq.upper(),RNA]\n", - " elif unidecode(tipo_seq.upper()) in [\"PROTEIN\",\"PROTEINA\",\"PROT\"]:\n", - " protein=\"ABCDEFGHIKLMNPQRSTVWYZ\"\n", - " return [\"Proteína\", protein]\n", - " else:\n", - " raise ValueError(f\"O tipo {tipo_seq} não é válido. Os tipos de cadeia válida são: DNA, RNA ou proteina\") \n", - "\n", - "def pwm (seqs: list, tipo_seq: str,pseudo=0)->list(dict[str,float]):\n", - " '''\n", - " Esta função recebe uma lista de sequências alinhadas e devolve uma matriz desingada de position weigth matrix (PWM), onde se representa\n", - " a probabilidade de cada letra de um dado alfabeto biológico estar presente numa determinada posição.\n", - "\n", - " Parameters\n", - " ----------\n", - " seqs:list(str)\n", - " Contêm um conjunto de sequências alinhadas em formato de string\n", - "\n", - " tipo_seq:str\n", - " Tipo da sequencia que se pretende realiazar a PWM. Pode assumir o valor de DNA, RNA, protein, proteína ou prot\n", - "\n", - " pseudo: int ou float\n", - " Valor a utilizar para realizar a pseudocontagem. Por padrão o valor é 0\n", - "\n", - " Returns\n", - " -------\n", - " PWM:list(dict)\n", - " Valor da probabilidade de cada letra do alfabeto estar presente em cada posição das sequências\n", - " \n", - " Raises\n", - " ------\n", - " AssertionError\n", - " Quando um elemento de uma das sequências fornecidas não está presente no alfabeto utilizado\n", - "\n", - " Quando o tamanho das sequências fornecidas é diferente\n", - " '''\n", - " alfa=alfabeto(tipo_seq)\n", - " \n", - " tamanho=[]\n", - " \n", - " for I,seq in enumerate(seqs):\n", - " tamanho.append(len(seq))\n", - " for pos,elem in enumerate(seq):\n", - " assert elem in alfa[1],f\"Na sequencia {seq}, o elemento {elem} na posição {pos+1} não se encontra no alfabeto do {alfa[0]}\"\n", - " assert tamanho[I]==tamanho[I-1],f\"A sequência {seq} não possui o mesmo tamanho que as restantes\"\n", - "\n", - " elementos_coluna=list(zip(*seqs))\n", - "\n", - " PWM=[]\n", - "\n", - " for coluna in elementos_coluna:\n", - " contagem={}\n", - " for elem in alfa[1]:\n", - " contagem[elem]=(coluna.count(elem) + pseudo)/(len(seqs)+len(alfa[1])*pseudo)\n", - " \n", - " PWM.append(contagem) \n", - " \n", - " return PWM\n", - "\n", - "def prob_seq (seq: str, pwm: list(dict[str,float])):\n", - " '''\n", - " Esta função calcula a probabilidade de uma determinada sequencia ter sido gerada pela PWM\n", - "\n", - " Parameters\n", - " ---------\n", - " seq:str\n", - " Sequência que se pretende calcular a probabilidade de ter sido gerada pela PWM\n", - " \n", - " pwm:list(dict[str,floar])\n", - " Corresponde às probabilidades de cada elemento aparecer nas várias posições da sequência\n", - "\n", - " Returns\n", - " -------\n", - " prod:float\n", - " Probabilidade de a sequencia fornecida ter sido gerada pela PWM\n", - "\n", - " Raises\n", - " ------\n", - " AssertionError\n", - " Quando o tamanho da sequência não é igual ao tamanho da PWM\n", - "\n", - " '''\n", - " assert len(seq)<=len(pwm),f\"A sequência {seq} não é do mesmo tamanho que a PWM\"\n", - "\n", - " prod=1\n", - " for I,elem in enumerate(seq):\n", - " prod=prod*pwm[I][elem]\n", - " return prod\n", - "\n", - "def seq_mais_provavel(seq,pwm,resultado=\"Max\"):\n", - " '''\n", - " Esta função recebe uma sequência e utiliza a PWM para determinar qual a subsequência mais provável de ter sido gerada pela PWM\n", - "\n", - " Parameters\n", - " --------\n", - " seq: str\n", - " sequência na qual se pretende analisar a probablidade de cada subsequência ter sido gerada pela PWM\n", - "\n", - " pwm: list(dict[str,float])\n", - " PWM de um determinado alinhamento\n", - "\n", - " Resultado: str\n", - " Corresponde ao valor que se pretende obter, por exemplo, quando assume o valor \"Máximo\" devolve a(s) subsequência(s) \n", - " com maior probabilidade de ter sido gerada pela PWM, quando assume o valor mínimo devolve a(s) sequência(s) com menor probabildade\n", - " de serem formadas pela PWM\n", - "\n", - " Returns\n", - " -------\n", - " str\n", - " Corresponde à sequência de maior/menor probabilidade\n", - " '''\n", - "\n", - " assert len(seq)>=len(pwm),f'''\n", - " A sequência {seq} não pode ser utilizada para determinar a sequência mais próvavel. A sequência deve ter, no mínimo, o mesmo tamnho da PWM\n", - " '''\n", - " w=len(pwm)\n", - " snips=[seq[P:P+w] for P in range(len(seq)-w+1)]\n", - " res={}\n", - " for snip in snips:\n", - " prob=prob_seq(snip,pwm)\n", - " res[snip]=prob\n", - " \n", - " if resultado.upper() in ['MAX','MAXIMO']:\n", - " return max(res, key=res.get)\n", - " \n", - " if resultado.upper() in ['MIN','MINIMO']:\n", - " return min(res, key=res.get)\n", - " \n", - "def pssm(seqs,tipo_seq,pseudo=1):\n", - " import math\n", - " alfa=alfabeto(tipo_seq)\n", - " tamanho=[]\n", - " for I,seq in enumerate(seqs):\n", - " tamanho.append(len(seq))\n", - " for pos,elem in enumerate(seq):\n", - " assert elem in alfa[1],f\"Na sequencia {seq}, o elemento {elem} na posição {pos+1} não se encontra no alfabeto do {alfa[0]}\"\n", - " assert tamanho[I]==tamanho[I-1],f\"A sequência {seq} não possui o mesmo tamanho que as restantes\"\n", - "\n", - " elementos=list(zip(*seqs))\n", - "\n", - " PSSM=[{b:math.log2(((elemento.count(b)+pseudo)/(len(seqs)+len(alfa[1])*pseudo))/(1/len(alfa[1]))) for b in alfa[1]} for elemento in elementos]\n", - "\n", - " return PSSM\n" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'A': 1.1926450779423958,\n", - " 'C': -0.8073549220576043,\n", - " 'G': -0.8073549220576043,\n", - " 'T': -0.8073549220576043},\n", - " {'A': -0.8073549220576043,\n", - " 'C': -0.8073549220576043,\n", - " 'G': 1.1926450779423958,\n", - " 'T': -0.8073549220576043},\n", - " {'A': 0.19264507794239583,\n", - " 'C': 0.19264507794239583,\n", - " 'G': -0.8073549220576043,\n", - " 'T': 0.19264507794239583}]" - ] - }, - "execution_count": 119, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pssm((\"AGC\",\"AGA\",\"AGT\"),\"DNA\")" - ] - }, - { - "cell_type": "code", - "execution_count": 115, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'prob_seq(\"AGC\",[{\\'A\\': 1.0, \\'C\\': 0.0, \\'G\\': 0.0, \\'T\\': 0.0},\\n {\\'A\\': 0.0, \\'C\\': 0.0, \\'G\\': 1.0, \\'T\\': 0.0},\\n {\\'A\\': 0.5, \\'C\\': 0.25, \\'G\\': 0.0, \\'T\\': 0.25}])'" - ] - }, - "execution_count": 115, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"\"\"seq_mais_provavel(\"AGC\", [\n", - " {'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.3333333333333333, 'C': 0.3333333333333333, 'G': 0.0, 'T': 0.3333333333333333}\n", - "], resultado=\"MAX\")\"\"\"\n", - "\n", - "seq_mais_provavel(\"AGC\", [\n", - " {'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.3333333333333333, 'C': 0.3333333333333333, 'G': 0.0, 'T': 0.3333333333333333}\n", - "], resultado=\"MIN\")\n", - "\"\"\"prob_seq(\"AGC\",[{'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.5, 'C': 0.25, 'G': 0.0, 'T': 0.25}])\"\"\"\n", - "#pwm ((\"AGC\",\"AGA\",\"AGT\",\"AGA\"),\"DNA\")\n", - "#prob_seq(\"AGC\",pwm((\"AGC\",\"AGA\",\"AGT\",\"AGA\"),\"DNA\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_alfabeto_caracter_errado_dna (__main__.TestMOTIFS.test_alfabeto_caracter_errado_dna) ... ok\n", - "test_alfabeto_caracter_errado_protein (__main__.TestMOTIFS.test_alfabeto_caracter_errado_protein) ... ok\n", - "test_alfabeto_caracter_errado_rna (__main__.TestMOTIFS.test_alfabeto_caracter_errado_rna) ... ok\n", - "test_alfabeto_dna_valido (__main__.TestMOTIFS.test_alfabeto_dna_valido) ... ok\n", - "test_alfabeto_protein_valido (__main__.TestMOTIFS.test_alfabeto_protein_valido) ... ok\n", - "test_alfabeto_rna_valido (__main__.TestMOTIFS.test_alfabeto_rna_valido) ... ok\n", - "test_prob_seq_caracter_errado (__main__.TestMOTIFS.test_prob_seq_caracter_errado) ... ok\n", - "test_prob_seq_valido (__main__.TestMOTIFS.test_prob_seq_valido) ... ok\n", - "test_pssm_caracter_invalido (__main__.TestMOTIFS.test_pssm_caracter_invalido) ... ok\n", - "test_pssm_tamanhos_de_sequencia_diferentes (__main__.TestMOTIFS.test_pssm_tamanhos_de_sequencia_diferentes) ... ok\n", - "test_pssm_valido (__main__.TestMOTIFS.test_pssm_valido) ... ok\n", - "test_pwm_caracter_invalido_DNA (__main__.TestMOTIFS.test_pwm_caracter_invalido_DNA) ... ok\n", - "test_pwm_caracter_invalido_RNA (__main__.TestMOTIFS.test_pwm_caracter_invalido_RNA) ... ok\n", - "test_pwm_caracter_invalido_protein (__main__.TestMOTIFS.test_pwm_caracter_invalido_protein) ... ok\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "test_pwm_tamanhos_diferentes (__main__.TestMOTIFS.test_pwm_tamanhos_diferentes) ... ok\n", - "test_pwm_valid (__main__.TestMOTIFS.test_pwm_valid) ... ok\n", - "test_seq_mais_provavel_max_prob (__main__.TestMOTIFS.test_seq_mais_provavel_max_prob) ... ok\n", - "test_seq_mais_provavel_min_prob (__main__.TestMOTIFS.test_seq_mais_provavel_min_prob) ... ok\n", - "\n", - "----------------------------------------------------------------------\n", - "Ran 18 tests in 0.028s\n", - "\n", - "OK\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 123, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import unittest\n", - "\n", - "class TestMOTIFS(unittest.TestCase):\n", - " \n", - " def test_alfabeto_caracter_errado_dna(self):\n", - " with self.assertRaises(ValueError):\n", - " alfabeto(\"DNA%\")\n", - "\n", - " def test_alfabeto_caracter_errado_rna(self):\n", - " with self.assertRaises(ValueError):\n", - " alfabeto(\"RNA/\")\n", - "\n", - " def test_alfabeto_caracter_errado_protein(self):\n", - " with self.assertRaises(ValueError):\n", - " alfabeto(\"protein@\")\n", - "\n", - " def test_alfabeto_dna_valido(self):\n", - " self.assertEqual(alfabeto(\"DNA\"), [\"DNA\", \"ACGT\"])\n", - "\n", - " def test_alfabeto_rna_valido(self):\n", - " self.assertEqual(alfabeto(\"RNA\"), [\"RNA\", \"ACGU\"])\n", - "\n", - " def test_alfabeto_protein_valido(self):\n", - " self.assertEqual(alfabeto(\"protein\"), [\"Proteína\", \"ABCDEFGHIKLMNPQRSTVWYZ\"])\n", - "\n", - " def test_pwm_caracter_invalido_DNA(self):\n", - " with self.assertRaises(AssertionError):\n", - " pwm((\"ACAT\", \"AGCP\", \"TGGT\"), \"DNA\")\n", - " \n", - " def test_pwm_caracter_invalido_RNA(self):\n", - " with self.assertRaises(AssertionError):\n", - " pwm((\"A&AU\", \"AGCU\", \"AUAU\"), \"RNA\")\n", - "\n", - " def test_pwm_caracter_invalido_protein(self):\n", - " with self.assertRaises(AssertionError):\n", - " pwm((\"ACMN\", \"TGCC\", \"WYZ/\"), \"protein\")\n", - " \n", - " def test_pwm_tamanhos_diferentes(self):\n", - " with self.assertRaises(AssertionError):\n", - " pwm((\"ACGT\", \"TGCA\", \"ACG\"), \"DNA\")\n", - "\n", - " def test_pwm_valid(self):\n", - " self.assertEqual(pwm((\"AGC\", \"AGA\", \"AGT\"), \"DNA\"), [\n", - " {'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.3333333333333333, 'C': 0.3333333333333333, 'G': 0.0, 'T': 0.3333333333333333}])\n", - "\n", - " def test_prob_seq_caracter_errado(self):\n", - " with self.assertRaises(AssertionError):\n", - " prob_seq(\"AGC/\",[{'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.3333333333333333,\n", - " 'C': 0.3333333333333333,\n", - " 'G': 0.0,\n", - " 'T': 0.3333333333333333}] )\n", - "\n", - " def test_prob_seq_valido(self):\n", - " self.assertEqual(prob_seq(\"AGC\", [{'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.3333333333333333,\n", - " 'C': 0.3333333333333333,\n", - " 'G': 0.0,\n", - " 'T': 0.3333333333333333}]),0.3333333333333333 ) \n", - "\n", - " def test_seq_mais_provavel_max_prob(self): \n", - " self.assertEqual(seq_mais_provavel(\"AGC\", [\n", - " {'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.3333333333333333, 'C': 0.3333333333333333, 'G': 0.0, 'T': 0.3333333333333333}\n", - " ], resultado=\"MAX\"),\"AGC\")\n", - " \n", - "\n", - " def test_seq_mais_provavel_min_prob(self):\n", - " self.assertEqual(seq_mais_provavel(\"AGC\", [\n", - " {'A': 1.0, 'C': 0.0, 'G': 0.0, 'T': 0.0},\n", - " {'A': 0.0, 'C': 0.0, 'G': 1.0, 'T': 0.0},\n", - " {'A': 0.3333333333333333, 'C': 0.3333333333333333, 'G': 0.0, 'T': 0.3333333333333333}\n", - " ], resultado=\"MIN\"),\"AGC\")\n", - "\n", - " def test_pssm_tamanhos_de_sequencia_diferentes(self):\n", - " with self.assertRaises(AssertionError):\n", - " pssm((\"ACT\", \"TGCA\", \"TCG\"), \"DNA\")\n", - "\n", - " def test_pssm_caracter_invalido(self):\n", - " with self.assertRaises(AssertionError):\n", - " pssm((\"AC/\", \"UGC\", \"UCG\"), \"RNA\")\n", - " \n", - " def test_pssm_valido(self):\n", - " self.assertEqual(pssm([\"AGC\", \"AGA\", \"AGT\"], \"DNA\"), [\n", - " {'A': 1.1926450779423958, 'C': -0.8073549220576043, 'G': -0.8073549220576043, 'T': -0.8073549220576043},\n", - " {'A': -0.8073549220576043, 'C': -0.8073549220576043, 'G': 1.1926450779423958, 'T': -0.8073549220576043},\n", - " {'A': 0.19264507794239583, 'C': 0.19264507794239583, 'G': -0.8073549220576043, 'T': 0.19264507794239583}\n", - " ])\n", - "\n", - "suite = unittest.TestLoader().loadTestsFromTestCase(TestMOTIFS)\n", - "unittest.TextTestRunner(verbosity=3).run(suite)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}