O módulo Bio.Align

O módulo Bio.Align é um conjunto de funções e classes para lidar com alinhamentos de seqüências. Está dividido em três "submódulos"(arquivos):

  • Generic(.py)
  • FormatConvert(.py)
  • Aligninfo(.py)

O submódulo Generic

Esse submódulo é formado por uma única classe: Alignment. De maneira geral, ela define um novo tipo para alinhamentos.

A classe Alignment:

Essa é uma classe "base" para representar alinhamentos de maneira geral, mas pode ser herdada por uma nova classe para definir um novo tipo que lide com formatos de alinhamentos específicos.

A classe recebe apenas um argumento, o alfabeto do alinhamento. Como é um alinhamento, só faz sentido ter um alfabeto que aceite Gaps.

Os atributos:

  • O Alfabeto, que é passado como argumento
  • _records, uma lista, que, através da rotina "add_sequence", adicionar uma SeqRecord

Os métodos:

  • def get_all_seqs(self):
    • Retorna uma lista de SeqRecords de todas as seqüências do alinhamento.
  • def iter(self) :
    • Faz a iteração sobre as linhas do alinhamento.
  • def get_seq_by_num(self, number):
    • Retorna uma seqüência pelo índice da mesma no atributo self._record
  • def get_alignment_length(self):
    • Um alinhamento deve conter todas as seqüências com um mesmo tamanho, entretanto, caso sejam passadas seqüências desalinhadas, através dessa função obtêm-se o valor da seqüência mais longa.
  • def add_sequence(self, descriptor, sequence, start = None, end = None, weight = 1.0):
    • Adiciona uma seqüência, na forma de uma SeqRecord, ao alinhamento. Vale ressaltar que a seqüência é apenas adicionada ao conjunto de seqüências, sendo suposto que esta já tenha sido prealinhada com as demais.
    • Os Argumentos:
      • descriptor - Um identificador da seqüência, que será usado no atributo .id da SeqRecord resultante
      • sequence - Uma string com a seqüência de nucleotídeos ou aminoácidos
      • start - Determina o ínicio da seqüência. Para mais detalhes veja o código.
      • end - Determina o fim da seqüência. Para mais detalhes veja o código.
      • weight - Determina o peso da seqüência no alinhamento.
  • def get_column(self,col):
    • Retorna uma string contendo os valores da coluna no alinhamento. O argumento col, obviamente, é o índice da coluna

O submódulo FormatConvert:

Contém uma única classe: FormatConverter. Essa é uma ferramenta para fazer a conversão de diferentes formatos de alinhamentos.

O funcionamento ocorre da seguinte maneira: Dado um alinhamento em formato específico, esse alinhamento é convertido em um alinhamento básico (Aligment), e então convertido para o formato especificado. Atualmente, apenas os formatos Clustal (*.aln) e Fasta (*.fasta, *.fas) são suportados.

Em breve mais detalhes.

O submódulo AlignInfo:

Esse submódulo é constituido por duas classes: SummaryInfo e PSSM

A classe SummaryInfo

Essa classe reune métodos para analizar a quantidade e a localização da informação no alinhamento.

Os métodos:

  • def dumb_consensus(self, threshold = .7, ambiguous = "X", consensus_alpha = None, require_multiple = 0):
    • Retorna uma seqüência consenso simples na forma de um Seq. Esse função percorre coluna por coluna do alinhamento e conta o número vezes que determinado nucleotídeo ou aminoácido aparece. Caso a porcentagem do mais comum supere determinado valor mínimo (threshold), adiciona-se esse à seqüência consenso. Caso contrário, adiciona-se à seqüência consenso um caracter de ambiguidade.
    • Argumentos:
      • threshold: porcentagem mínima do caracter mais comum para que esse seja adicionado na seqüência consenso.
      • ambiguous: O caracter de ambiguidade que será adicionado caso o "threshold" não seja superado.
      • consensus_alpha: O alfabeto da seqüência consenso. Caso nenhum seja específicado, a função tenta identifica-lo.
      • require_multiple: Caso configurado como 1, vai exigir que mais de 1 seqüência seja parte do alinhamento para adiciona-la no consenso, isto é, não apena uma seqüência e gaps (Não entendi direito e portanto traduzi literalmente do fonte)
  • def gap_consensus(self, threshold = .7, ambiguous = "X", consensus_alpha = None, require_multiple = 0):
    • O mesmo que dumb_consensus(), porém permite gaps na seqüência retornada.
  • def _guess_consensus_alphabet(self):
    • Função interna. Tenta identificar o alfabeto de uma seqüência consenso, pelo alfabeto da primeira seqüência do alinhamento.
  • def replacement_dictionary(self, skip_chars = []):
    • Gera um dicionário de mutações, do tipo {('A', 'C') : 10, ('C', 'A') : 12, ('G', 'C') : 15 ….}, que pode ser usado para gerar uma matriz de substituição. Caso as seqüências tenham diferentes pesos, leva-se em consideração o peso das mesmas.
    • Realiza operações como a do quadro abaixo, somando-se os resultados de cada coluna, até o final do alinhamento.
    • Argumentos:
      • skip_chars: Uma lista com os caracters que não devem ser incluídos no dicionário, por exemplo, Xs e Ns,

GTATC 0.5
AT--C 0.8
CTGTC 1.0
Para primeira coluna temos:

('A', 'G') : 0.5 * 0.8 = 0.4
('C', 'G') : 0.5 * 1.0 = 0.5
('A', 'C') : 0.8 * 1.0 = 0.8

  • def _pair_replacement(self, seq1, seq2, weight1, weight2, start_dict, ignore_chars):
    • Função interna. Identifica as substituições entre duas seqüências.
    • Argumentos:
      • seq1 e seq2: As duas seqüências a serem comparadas.
      • weight1, weight2 - O peso das seqüências seq1 e seq2 respectivamente.
      • start_dict - O dicionário contendo as informações de substituições iniciais.
      • ignore_chars - Uma lista com os caracteres a serem ignorados, Gaps ("-") por exemplo.
    • Retorna o dicionário inicial (strat_dict) com as substituições atualizadas.
  • def _get_base_replacements(self, skip_items = []):
    • Função interna. Gera um dicionário "zerado" com todas as possíveis combinações de substituições dado um alfabeto. Por exemplo- {('A', 'C') : 0, ('C', 'A') : 0, ('G', 'C') : 0 ….. }
    • Argumentos:
      • skip_items: Lista com os caracteres que não devem ser incluídos no dicionário.
    • Retorna:
      • O dicionário "zerado" e uma lista com os caracteres do alfabeto a serem ignorados.
  • def pos_specific_score_matrix(self, axis_seq = None, chars_to_ignore = []):
    • Cria uma PSSM (Position Specific Score Matrix) que é uma maneira alternativa de se analisar seqüências consenso.
    • Argumentos:
      • chars_to_ignore: Uma lista com os caracteres que não devem ser incluídos na PSSM. Por padrão, gaps ("-") não são incluídos.
      • axis_seq: Um argumento opcional (deve ser um objeto Seq) especificando que seqüência deve ser colocada no eixo da PSSM. Se nada é passado, a seqüência consenso será utilizada.
    • Retorna:
      • Um objeto PSSM
  • def _get_base_letters(self, letters):
    • Função interna. Gera um dicionário com todas as letras especificadas em "letters" como chave e seu valor 0.
    • Argumentos:
      • letters: string especificando que letras devem ser utilizadas como chave no dicionário
    • Retorna:
      • Dicionário com todas as letras como chaves, todas com valores 0.
  • def information_content(self, start = 0, end = None, e_freq_table = None, log_base = 2, chars_to_ignore = []):
    • Calcula a quantidade de informação para cada posição de um alinhamento.
    • Argumentos:
      • start, end: as posições iniciais e finais, respectivamente, que delimitam a região a ser analisada. Caso nenhum valor seja passado, é calculado para todo o alinhamento.
      • e_freq_table: Um dicionário especificando a freqüência esperada de cada resíduo/nucleotídeo ({'G' : 0.4, 'C' : 0.4, 'T' : 0.1, 'A' : 0.1}). Gaps não devem estar incluídos.
      • log_base: A base do logarítimo que será utilizado no cálculo da quantidade de informação. O padrão é 2, e o resultado é então dado em "bits" (Consulte o Tutorial oficial para detalhes sobre o cálculo).
      • chars_to_ignore - Uma lista de caracteres que devem ser ignorados no cálculo da quantidade de informação.
    • Retorna:
      • O valor da quantidade de informação para cada posição do alinhamento.
  • def _get_letter_freqs(self, residue_num, all_records, letters, to_ignore):
    • Função interna. Determina a freqüência de determinados caracteres em um alinhamento.
    • Argumentos:
      • residue_num: O índice da coluna do alinhamento a ser analisado.
      • all_records: Todas as seqüências do alinhamento.
      • letter - Os caracteres (letras) que devem ser obtidas as freqüências.
      • to_ignore: Lista com os caracteres que devem ser ignorados.
    • Retorna:
      • Um dicionário com a freqüência (valor) de cada letra especificada (chave).
  • def _get_column_info_content(self, obs_freq, e_freq_table, log_base, random_expected):
    • Calcula a quantidade de informação em determinada coluna de um alinhamento.
    • Argumentos:
      • obs_freq: A freqüência observada de cada letra na coluna.
      • e_freq_table: Argumento opcional especifcando as freqüências esperadas de cada letra.
      • log_base: A base do logarítimo que será utilizado no cálculo da quantidade de informação. (Consulte o Tutorial oficial para detalhes sobre o cálculo).
  • def get_column(self,col):
    • Dado o índice de uma coluna do alinhamento, retorna os caracteres dessa.

A classe PSSM

Essa classe representa uma PSSM (Position Specific Score Matrix), que é uma alternativa da análise de seqüências consenso.

É inicializada com os dados a serem contidos na PSSM. Esses dados devem estar em uma lista com i elementos, onde i representa cada posição da alinhamento da PSSM. Cada elemento deve ter a seguinte estrutura:

  • lista[i][0]: O caracter que representa a posição i da seqüência "eixo" da PSSM.
  • lista[i][1]: Um dicionário com os dados de contagem de cada caracter possível nessa posição.

Em geral, o usuário não precisa instanciar manualmente essa classe; ele deve obter uma PSSM usando a função "pos_specific_score_matrix" de um objeto SummaryInfo. As "possibilidades de uso" de um objeto PSSM são:

  • print nome_objeto: imprime a PSSM.
  • nome_objeto[x]: Retorna os dados da PSSM na posição x
  • nome_objeto.get_residue[x]: Retorna o caracter da posição x da PSSM
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License