&hdZddlZddlmZddlmZddlmZddlmZejdedZ ed d Z Gd d Z e Z d Z dZdZ d%dZdZdZdZdZdZdZefdZGddZGddZGddZdZdZd%dZeZeZ d d!l mZmZe"d#k(rdd$l#m$Z$e$yy#e!$rejd"eY.wxYw)&ai!Pairwise sequence alignment using a dynamic programming algorithm. This provides functions to get global and local alignments between two sequences. A global alignment finds the best concordance between all characters in two sequences. A local alignment finds just the subsequences that align the best. Local alignments must have a positive score to be reported and they will not be extended for 'zero counting' matches. This means a local alignment will always start and end with a positive counting match. When doing alignments, you can specify the match score and gap penalties. The match score indicates the compatibility between an alignment of two characters in the sequences. Highly compatible characters should be given positive scores, and incompatible ones should be given negative scores or 0. The gap penalties should be negative. The names of the alignment functions in this module follow the convention XX where is either "global" or "local" and XX is a 2 character code indicating the parameters it takes. The first character indicates the parameters for matches (and mismatches), and the second indicates the parameters for gap penalties. The match parameters are:: CODE DESCRIPTION & OPTIONAL KEYWORDS x No parameters. Identical characters have score of 1, otherwise 0. m A match score is the score of identical chars, otherwise mismatch score. Keywords ``match``, ``mismatch``. d A dictionary returns the score of any pair of characters. Keyword ``match_dict``. c A callback function returns scores. Keyword ``match_fn``. The gap penalty parameters are:: CODE DESCRIPTION & OPTIONAL KEYWORDS x No gap penalties. s Same open and extend gap penalties for both sequences. Keywords ``open``, ``extend``. d The sequences have different open and extend gap penalties. Keywords ``openA``, ``extendA``, ``openB``, ``extendB``. c A callback function returns the gap penalties. Keywords ``gap_A_fn``, ``gap_B_fn``. All the different alignment functions are contained in an object ``align``. For example: >>> from Bio import pairwise2 >>> alignments = pairwise2.align.globalxx("ACCGT", "ACG") For better readability, the required arguments can be used with optional keywords: >>> alignments = pairwise2.align.globalxx(sequenceA="ACCGT", sequenceB="ACG") The result is a list of the alignments between the two strings. Each alignment is a named tuple consisting of the two aligned sequences, the score and the start and end positions of the alignment: >>> print(alignments) [Alignment(seqA='ACCGT', seqB='A-CG-', score=3.0, start=0, end=5), ... You can access each element of an alignment by index or name: >>> alignments[0][2] 3.0 >>> alignments[0].score 3.0 For a nice printout of an alignment, use the ``format_alignment`` method of the module: >>> from Bio.pairwise2 import format_alignment >>> print(format_alignment(*alignments[0])) ACCGT | || A-CG- Score=3 All alignment functions have the following arguments: - Two sequences: strings, Biopython sequence objects or lists. Lists are useful for supplying sequences which contain residues that are encoded by more than one letter. - ``penalize_extend_when_opening``: boolean (default: False). Whether to count an extension penalty when opening a gap. If false, a gap of 1 is only penalized an "open" penalty, otherwise it is penalized "open+extend". - ``penalize_end_gaps``: boolean. Whether to count the gaps at the ends of an alignment. By default, they are counted for global alignments but not for local ones. Setting ``penalize_end_gaps`` to (boolean, boolean) allows you to specify for the two sequences separately whether gaps at the end of the alignment should be counted. - ``gap_char``: string (default: ``'-'``). Which character to use as a gap character in the alignment returned. If your input sequences are lists, you must change this to ``['-']``. - ``force_generic``: boolean (default: False). Always use the generic, non-cached, dynamic programming function (slow!). For debugging. - ``score_only``: boolean (default: False). Only get the best score, don't recover any alignments. The return value of the function is the score. Faster and uses less memory. - ``one_alignment_only``: boolean (default: False). Only recover one alignment. The other parameters of the alignment function depend on the function called. Some examples: - Find the best global alignment between the two sequences. Identical characters are given 1 point. No points are deducted for mismatches or gaps. >>> for a in pairwise2.align.globalxx("ACCGT", "ACG"): ... print(format_alignment(*a)) ACCGT | || A-CG- Score=3 ACCGT || | AC-G- Score=3 - Same thing as before, but with a local alignment. Note that ``format_alignment`` will only show the aligned parts of the sequences, together with the starting positions. >>> for a in pairwise2.align.localxx("ACCGT", "ACG"): ... print(format_alignment(*a)) 1 ACCG | || 1 A-CG Score=3 1 ACCG || | 1 AC-G Score=3 To restore the 'historic' behaviour of ``format_alignemt``, i.e., showing also the un-aligned parts of both sequences, use the new keyword parameter ``full_sequences``: >>> for a in pairwise2.align.localxx("ACCGT", "ACG"): ... print(format_alignment(*a, full_sequences=True)) ACCGT | || A-CG- Score=3 ACCGT || | AC-G- Score=3 - Do a global alignment. Identical characters are given 2 points, 1 point is deducted for each non-identical character. Don't penalize gaps. >>> for a in pairwise2.align.globalmx("ACCGT", "ACG", 2, -1): ... print(format_alignment(*a)) ACCGT | || A-CG- Score=6 ACCGT || | AC-G- Score=6 - Same as above, except now 0.5 points are deducted when opening a gap, and 0.1 points are deducted when extending it. >>> for a in pairwise2.align.globalms("ACCGT", "ACG", 2, -1, -.5, -.1): ... print(format_alignment(*a)) ACCGT | || A-CG- Score=5 ACCGT || | AC-G- Score=5 - Note that you can use keywords to increase the readability, e.g.: >>> a = pairwise2.align.globalms("ACGT", "ACG", match=2, mismatch=-1, open=-.5, ... extend=-.1) - Depending on the penalties, a gap in one sequence may be followed by a gap in the other sequence.If you don't like this behaviour, increase the gap-open penalty: >>> for a in pairwise2.align.globalms("A", "T", 5, -4, -1, -.1): ... print(format_alignment(*a)) A- -T Score=-2 >>> for a in pairwise2.align.globalms("A", "T", 5, -4, -3, -.1): ... print(format_alignment(*a)) A . T Score=-4 - The alignment function can also use known matrices already included in Biopython (in ``Bio.Align.substitution_matrices``): >>> from Bio.Align import substitution_matrices >>> matrix = substitution_matrices.load("BLOSUM62") >>> for a in pairwise2.align.globaldx("KEVLA", "EVL", matrix): ... print(format_alignment(*a)) KEVLA ||| -EVL- Score=13 - With the parameter ``c`` you can define your own match- and gap functions. E.g. to define an affine logarithmic gap function and using it: >>> from math import log >>> def gap_function(x, y): # x is gap position in seq, y is gap length ... if y == 0: # No gap ... return 0 ... elif y == 1: # Gap open penalty ... return -2 ... return - (2 + y/4.0 + log(y)/2.0) ... >>> alignment = pairwise2.align.globalmc("ACCCCCGT", "ACG", 5, -4, ... gap_function, gap_function) You can define different gap functions for each sequence. Self-defined match functions must take the two residues to be compared and return a score. To see a description of the parameters for a function, please look at the docstring for the function via the help function, e.g. type ``help(pairwise2.align.localds)`` at the Python prompt. N) namedtuple)BiopythonDeprecationWarning)BiopythonWarning)substitution_matricesaBio.pairwise2 has been deprecated, and we intend to remove it in a future release of Biopython. As an alternative, please consider using Bio.Align.PairwiseAligner as a replacement, and contact the Biopython developers if you still need the Bio.pairwise2 module.i AlignmentzseqA, seqB, score, start, endc*eZdZdZGddZdZy)alignayProvide functions that do alignments. Alignment functions are called as: pairwise2.align.globalXX or pairwise2.align.localXX Where XX is a 2 character code indicating the match/mismatch parameters (first character, either x, m, d or c) and the gap penalty parameters (second character, either x, s, d, or c). For a detailed description read the main module's docstring (e.g., type ``help(pairwise2)``). To see a description of the parameters for a function, please look at the docstring for the function, e.g. type ``help(pairwise2.align.localds)`` at the Python prompt. creZdZdZgdfddgdfdgdfdgd fd Zgdfd d gd fgddfddgdfdZdZdZdZy)align.alignment_functionzCallable class which impersonates an alignment function. The constructor takes the name of the function. This class will decode the name of the function to figure out how to interpret the parameters. matchmismatchzgmatch is the score to given to identical characters. mismatch is the score given to non-identical ones. match_dictzmatch_dict is a dictionary where the keys are tuples of pairs of characters and the values are the scores, e.g. ('A', 'C') : 2.5.match_fnz]match_fn is a callback function that takes two characters and returns the score between them.)xmdcopenextendzbopen and extend are the gap penalties when a gap is opened and extended. They should be negative.)openAextendAopenBextendBz~openA and extendA are the gap penalties for sequenceA, and openB and extendB for sequenceB. The penalties should be negative.gap_A_fngap_B_fnzgap_A_fn and gap_B_fn are callback functions that takes (1) the index where the gap is opened, and (2) the length of the gap. They should return a gap penalty.)rsrrc|jdrt|dk7r@td|jdrt|dk7rtdt||dd|d|d }}} |j|\}} |j |\}}d d g} | j || j |||_||_| |_ |j|_ |jddj|jd} | dz } |r | d|dz } |r | d|dz } | dz } | |_ y#t$rtd |wxYw#t$rtd |wxYw)z:Check to make sure the name of the function is reasonable.globalzfunction should be globalXXlocalzfunction should be localXXNzunknown match type zunknown penalty type sequenceA sequenceB(z, z) -> alignments z The following parameters can also be used with optional keywords of the same name. sequenceA and sequenceB must be of the same type, either strings, lists or Biopython sequence objects.  a  alignments is a list of named tuples (seqA, seqB, score, begin, end). seqA and seqB are strings showing the alignment between the sequences. score is the score of the alignment. begin and end are indexes of seqA and seqB that indicate where the alignment occurs. ) startswithlenAttributeError match2argsKeyError penalty2argsr function_name align_type param_names__name__join__doc__) selfnamer0 match_type penalty_type match_args match_doc penalty_args penalty_docr1docs \/mounts/lovelace/software/anaconda3/envs/py312/lib/python3.12/site-packages/Bio/pairwise2.py__init__z!align.alignment_function.__init__lsx(t9>()FGG)t9>()EFF$T**379d2hRL J K(, (C% I O,0,=,=l,K) k ' 4K   z *   | ,!%D (DO*D  ..DM]]O1TYYt/?/?%@$AARSC  C I;b))K=++  CDLG K$'::.%IJJ K O$'<\ z2align.alignment_function.decode..s@@sz'%s takes exactly %d argument (%d given)r)r%r&rrrr rrrrrpenalize_extend_when_openingrrrrzunknown parameter )rIrpenalize_end_gapsralign_globally)gap_char-) force_genericr) score_onlyr)one_alignment_onlyr) copyr*r1indextuple TypeErrorr/identity_matchdictionary_matchgetaffine_penalty ValueErrorr0)r5argskeywdskey_indexir rrrperrrrdefault_paramsr6defaultvaluens r>decodezalign.alignment_function.decodes [[]F S))*SY6'A AD{{} $$***!--33C8F=F3K>9DMIDs  $ @@@D4yC 0 011=))3t/?/?+@#d)LM Ac$**++##A&+37q'F4++A./FA%%a(G3++AE2j@@&*1gtAE{8E)7x)HF:&FA%%a(L8)9$q')BF:&FA%%a(F2++AE2h>>#'7DQK&D$BAFB)7fb)IF:&)7fb)IF:&FA%%a(G3++AE2i??59!a!e_2E7E7$BAFB)7w)KF:&)7w)KF:&FA$'9$:J:J1:M9P%QRRCc$**++J:A>B^Aq12^Aq"56^Aq"563$doo&AB!4??h#>?!$!) N"0 9 g%zz$8t  9./E JAv M  A.3UGaK.@*+M  As MM>=M>c<|j|i|}tdi|S)z,Call the alignment instance already created.rC)rf_align)r5r\r]s r>__call__z!align.alignment_function.__call__s% T[[$1&1F#F# #N) r2 __module__ __qualname__r4r,r.r?rfrirCrjr>alignment_functionr :s b*%E ) A *b"A 9&Z(A *0 dS j $rjrmc|j|}t|}|jj}|j|d<tdt f|}||S)z=Call alignment_function() to check and decode the attributes.r4rm)rmtype__dict__rSr4object)r5attrwrapper wrapper_type wrapper_dictnew_alignment_functions r> __getattr__zalign.__getattr__s\))$/G} #,,113 ")// Y!%&:VI|!T%d++rjN)r2rkrlr4rmrwrCrjr>r r $s*|$|$| ,rjr c |r|sgS ||z||zt|ts t|}t|ts t|}|s$|ds|drt j dt | sft|trVt|trF|j|j} } |j|j}}t|||| | |||||| }nt|||||||| }|\}}}| r|St|||}t||||||||| || }|sCt||\}}|Dcgc]\}\}}|||ff}}}}t||||||||| ||d }|S#t$r tdwxYwcc}}}w)zReturn optimal alignments between two sequences (PRIVATE). This method either returns a list of optimal alignments (with the same score) or just the optimal score. zboth sequences must be of the same type, either string/sequence object or list. Gap character must fit the sequence type (string or list)rrGz]"penalize_end_gaps" should not be used in local alignments. The resulting score may be wrong.T)reverse)rV isinstanceliststrwarningswarnrrZrr_make_score_matrix_fast_make_score_matrix_generic _find_start_recover_alignments_reverse_matrices)r%r&rrrrIrLrMrNrPrQrRopen_Aextend_Aopen_Bextend_Bmatrices score_matrix trace_matrix best_scorestarts alignmentszrys r>rhrhs& I  HH i & N i & N 037H7K  <   x 0 x 0#==(//#==(//*        (     .          .6*L,  z> BF% J %6|\%R" l/566)!Va1q!f+66(              {   5   \7s E+E3E0c rd}t|t|} } ggc} t| dzD]5} jdg| dzz|r| jdg| dzz7t| dzD]} |dr d| } nd} | | d<t| dzD]} |dr d| } nd} | d| <td| dzD]td| dzD]dz dz ||dz |dz z}|ds/| k(r*dz }tfdtD}n5dz dz}tfdtD}|ds/| k(r*dz }tfdtD}n5dz dz}tfdtD}t|||||}t||}|s|dkr d<n|<|r1d}t |t |k(r|d z }t |t |k(r|dz }t |t |k(r|d z }t |t |k(r|d z }t |t |k(r|d z }|| <|s|}| fS) a;Generate a score and traceback matrix (PRIVATE). This implementation according to Needleman-Wunsch allows the usage of general gap functions and is rather slow. It is automatically called if you define your own gap functions. You can force the usage of this method with ``force_generic=True``. rrGNc3.K|] }|ywrArC)rDrrowrs r>rFz-_make_score_matrix_generic..s J!c!21!5 Jc3HK|]}||z zywrArC)rDrcolrrrs r>rFz-_make_score_matrix_generic..s0!FGL%a(8Cq+AA!"c3.K|] }|ywrArC)rDrrrs r>rFz-_make_score_matrix_generic..s J!a!5 Jrc3HK|]}||z zywrArC)rDrrrrrs r>rFz-_make_score_matrix_generic..s/!FGLOC(8Cq+AA!rrHr rK)r*rangeappendmaxrint)r%r&rrrrLrMrQlocal_max_scorelenAlenBrr`score nogap_scorerow_open row_extendcol_open col_extendr trace_scorerrrs `` @@@r>rrsN"OYY$D!#RL, 4!8_5TFdQh/0   $( 3 454!8_# Q QNEE" Q # 4!8_# Q QNEE" Q #Qq!95D1H%8 5C S1W%cAg.9S1W-yq/ABC %Q'C4K',S1W5 JuSz JJ ',S1W5a8HH !KPQT:! %Q'C4K'a05 JuSz JJ 'a05a8HH !KPQT:! [(J*UJ!/:>O!j1n), S!#&)3 S!#&  $Z(881$K>T*%551$K #tJ'771$K>T*%551$K #tJ'772%K)4 S!#&q8 595v $ z 11rjc td|||} td|||} d} t|t|}}gg}}t|dzD]5}|jdg|dzz| r|jdg|dzz7t|dzD] }|drt||||}nd}|||d<"t|dzD] }|drt||||}nd}||d|<"dg}td|dzD]"}|jt|d|z||$td|dzD]}t|d|z||}td|dzD]z}||dz |dz |||dz ||dz z}|ds||k(r|||dz }|}n|||dz | z}||z}t ||}|ds||k(r||dz |}||}n||dz || z}|||z}t ||||<t ||||}t | |} | s|dkr d|||<n||||<| rt |}t ||}d} d}!t ||k(r| dz } t ||k(r| dz } t ||k(r|!dz }!t ||k(r|!dz }!d}"t |}#t ||#k(r|"dz }"||#k(r|"| z }"||#k(r|"|!z }"|"|||<}| s| }||fS)aGenerate a score and traceback matrix according to Gotoh (PRIVATE). This is an implementation of the Needleman-Wunsch dynamic programming algorithm as modified by Gotoh, implementing affine gap penalties. In short, we have three matrices, holding scores for alignments ending in (1) a match/mismatch, (2) a gap in sequence A, and (3) a gap in sequence B, respectively. However, we can combine them in one matrix, which holds the best scores, and store only those values from the other matrices that are actually used for the next step of calculation. The traceback matrix holds the positions for backtracing the alignment. rGrNrHr rKr)calc_affine_penaltyr*rrrr)$r%r&rrrrrrIrLrMrQ first_A_gap first_B_gaprrrrrr`r col_scorer row_scorerrrrrrrrow_score_rintcol_score_rintrow_trace_scorecol_trace_scorerbest_score_rints$ r>rrs0&a;WXK%a;WXKO YY$D!#R,L 4!8_5TFdQh/0   $( 3 454!8_# Q '68%AEE" Q#4!8_# Q '68%AEE" Q#I 1dQh   1v:x9U V  Qq!I5' VX'C D1H%E 5C S1W%cAg.9S1W-yq/ABC %Q'C4K',S1W5& ',S1W5 C&1 Hj1I%Q'C4K'a05&s^ 'a05 C&s^h6  :6IcN[)C.)DJ!/:>O!j1n)* S!#&)3 S!#&!%i!%in!5"#"#>^3#q(O #~5#q(O>^3#q(O #~5#r)O "&z"2 $71$K!_4?2K!_4?2K)4 S!#&KE 5 I5V $ z 11rjc t|t|} } |dd|dd}}g}g}|D]}|\}\}}d}|rd}n||dz |dz ff|vr!|dkr'|||}||dzz dzdk(r d|||<nGt| |z | |z  }|sd}| |z }| |z }||z |z|| dz |dz dz}||z |z|| dz |dz dz}||||||d|||fgz }|rt|tkrd}|j\}}}}}}}|dkDs|dkDrn|sk|dd|dd||||f}|s|r|rd}nt |||||||\}}n>|dzdk(r"|dz}|rd}n|dz}||z }||||dzz }d}n|dzdk(r(|dz}|dz}|dz}||||dzz }||||dzz }d}n|d zdk(r|dz}|dz}||||dzz }||z }d}ng|d vr2|d z}|rd}nYd}t ||||||||||||| ||d ||}|\}}}}}}n1|d k(r,|d z}d}t ||||||||||||| ||d ||}|\}}}}}}|r||fz }|j ||||}|s'||||k(rd}n|||dkrt||}d}|dkDs|dkDr|sk|sU| s#|j |ddd|ddd|fn"|j |ddd|ddd|f|r t|S|rt|tkrt|S)aDo the backtracing and return a list of alignments (PRIVATE). Recover the alignments by following the traceback matrix. This is a recursive procedure, but it's implemented here iteratively with a stack. sequenceA and sequenceB may be sequences, including strings, lists, or list-like objects. In order to preserve the type of the object, we need to use slices on the sequences instead of indexes. For example, sequenceA[row] may return a type that's not compatible with sequenceA, e.g. if sequenceA is a list and sequenceA[row] is a string. Thus, avoid using indexes and use slices, e.g. sequenceA[row:row+1]. Assume that client-defined sequence classes preserve these semantics. rNrGrHrKr$FTr )r rrr)r*rMAX_ALIGNMENTSpop_finish_backtrace_find_gap_openr_clean_alignments)r%r&rrrrrMrNrRrrryrrali_seqAali_seqB tracebacks in_processstartrrrbeginendtrace col_distance row_distancedead_endcol_gapcachers r>rrs:YY$D"1Q1QhHJJ% !zS Caq)*f4z %c*E !Q&!+)* S!#&tcz4#:..C#:L#:L ,8D1HsQw345   ,8D1HsQw345   xc3|C7H7M N  G% L Z>98DbD>5%QT"UV!!8DbD>8DbD>5%QT"UV! Z (({ Z>9z Z ((rjc$t|t|d}}|r||dz |dz ffg}|Sg}d}t|D]S}t|D]C}|||} tt| |z t|ks/|j | ||ffEU|S)zReturn a list of starting points (score, (row, col)) (PRIVATE). Indicating every possible place to start the tracebacks. rrG)r*rrabsr) rrrMnrowsncolsr tolerancerrrs r>rrPs |$c,q/&:5E 519567 M < 7CU| 7$S)#.EJ./0DOCMM53*"56 7 7 Mrjcg}g}idddddddddddddddd d d d d ddddddddddd dddd dd dddddddddddd d!}tt|d"D]r}g}g}tt|D]3}|j||||j||||5|j||j|t||fS)#z+Reverse score and trace matrices (PRIVATE).rGrKrHrJr"r r     rN)rrrrrrrrrrrrrrNr)rr*r) rrreverse_score_matrixreverse_trace_matrix reverse_tracer new_score_row new_trace_rowrs r>rrhs 1qQ !1&',-q23R9:B@BBHJBPRTV BBB "A')23521"RT BBBBBBBB MSa)*3  \*+ HC  c!23!7 8  |C/@/E!F G H ##M2##M23 !5 55rjcg}|D]}||vs|j|d}|t|kr[||\}}}}}| t|}n|dkr|t|z}||k\r||=Ct|||||||<|dz }|t|kr[|S)zTake a list of alignments and return a cleaned version (PRIVATE). Remove duplicates, make sure begin and end are set correctly, remove empty alignments. rrG)rr*r) runique_alignmentsr r`seqAseqBrrrs r>rrs , ) )  $ $U +, A c#$ $(9!(<%dE5# ;d)C 1WD /C C<!!$ (tUE3G! Q c#$ $ rjc|r|||dz ddz }|r|||dz ddz }||kDr!||t|t|z zz }||fS||kDr||t|t|z zz }||fS)zBAdd remaining sequences and fill with gaps if necessary (PRIVATE).rGNr$)r*)r%r&rrrrrNs r>rrs IcAgmm,, IcAgmm,, SyHH H =>> X  sHH H =>> X rjc d}| ||}t| D]}|dk(r|dz}||z }||||dzz }n|dz}||||dzz }||z }| ||| ||dzz}|s| |||k(rd}nWt|t|k(r3|dkDr.| ||sn1| j|dd|dd||||| ||f| ||rd}||||| |fS)z9Find the starting point(s) of the extended gap (PRIVATE).FrrGTrN)rrr)r%r&rrrrrrrNrrrgap_fntargetrT directionrrMr target_scorere actual_scores r>rrsI*H$S)L 6]   1HC  H  #a0 0H 1HC  #a0 0H  H#C(-ua!e0DD ,s"3C"8J"FH   l!3 3A$S)!!    $S)#. C %H=> XsCX ==rjc$t||zdzS)z%Print number with declared precision.g?)int)r precisions r>rrs q9}s" ##rjceZdZdZddZdZy)rWzCreate a match function for use in an alignment. match and mismatch are the scores to give when two residues are equal or unequal. By default, match is 1 and mismatch is 0. c ||_||_yInitialize the class.Nr r)r5r rs r>r?zidentity_match.__init__s   rjc<||k(r |jS|jS)z/Call a match function instance already created.rr5charAcharBs r>rizidentity_match.__call__s E>:: }}rjN)rGrr2rkrlr4r?rirCrjr>rWrWs ! rjrWceZdZdZddZdZy)rXa0Create a match function for use in an alignment. Attributes: - score_dict - A dictionary where the keys are tuples (residue 1, residue 2) and the values are the match scores between those residues. - symmetric - A flag that indicates whether the scores are symmetric. cjt|tjr t|}||_||_yr)rzrArraydict score_dict symmetric)r5rrs r>r?zdictionary_match.__init__s+ j"7"="= >j)J$"rjcd|jr||f|jvr||}}|j||fS)z1Call a dictionary match instance already created.)rrrs r>rizdictionary_match.__call__ s6 >>uenDOOC!%5Eu~..rjN)rGrrCrjr>rXrXs#/rjrXceZdZdZddZdZy)rZz.Create a gap function for use in an alignment.c~|dkDs|dkDr td|s||kr td||c|_|_||_y)rrz%Gap penalties should be non-positive.zJGap opening penalty should be higher than gap extension penalty (or equal)N)r[rrrI)r5rrrIs r>r?zaffine_penalty.__init__sP !8vzDE E+$3 "&v 4;,H)rjcZt||j|j|jS)z-Call a gap function instance already created.)rrrrI)r5rTlengths r>rizaffine_penalty.__call__$s&" DIIt{{D,M,M  rjN)rrrCrjr>rZrZs8 I rjrZc0|dkry|||zz}|s||z}|S)z/Calculate a penalty score for the gap function.rrrC)r rrrIpenaltys r>rr+s, {Vf_$G '6 Nrjc ttdDcgc]}g}}ttD]JttD].}||jtt|0L|Dcgc] }t |c}ttD]<t dj fdttD>ycc}wcc}w)z*Print out a matrix for debugging purposes.r c3>K|]}d||fzyw)z%*s NrC)rDjr`matrixndigitss r>rFzprint_matrix..@s'XQVwqz6!9Q<88XsN)rr*rr|rprintr3)rrmatrixTrr`rs` @@r> print_matrixr5s!VAY01ar1G1 3v; 6s6!9~& 6A AJ  c#fQil"34 5 66 ''!s1v'G 3v;   HHX%FSTIBWX X  2(s C6 C;c|}|}dx}} |} |s|dk7s|t|k7rtt|d||d|jdz dzdz}tt|d||d|jdz dzdz} tt|t| } n|rd} d}t|}t |t r$|D cgc]} | dz }} |D cgc]} | dz }} dj || g} d| zg} dj | | g}tt||||||D].\}\} }tt| t|}| jd j | ||jd j |||r-||ks||k\r#| jd j d|| |k(r#| jd j d || jdk(s|jdk(r$| jd j d| | jd j d |1|jd |d ddjdj| dj| dj|gScc} wcc} w)aRFormat the alignment prettily into a string. IMPORTANT: Gap symbol must be "-" (or ['-'] for lists)! Since Biopython 1.71 identical matches are shown with a pipe character, mismatches as a dot, and gaps as a space. Prior releases just used the pipe character to indicate the aligned region (matches, mismatches and gaps). Also, in local alignments, if the alignment does not include the whole sequences, now only the aligned part is shown, together with the start positions of the aligned subsequences. The start positions are 1-based; so start position n is the n-th base/amino acid in the *un-aligned* sequence. NOTE: This is different to the alignment's begin/end values, which give the Python indices (0-based) of the bases/amino acids in the *aligned* sequences. If you want to restore the 'historic' behaviour, that means displaying the whole sequences (including the non-aligned parts), use ``full_sequences=True``. In this case, the non-aligned leading and trailing parts are also indicated by spaces in the match-line. r rNrOrGrz {:>{width}})widthz {:^{width}}|.z Score=gr() r*r|countrrzr{format enumerateziprstripr3)align1align2rrrfull_sequences align_begin align_endstart1start2start_mas1_linem_lines2_linerebm_lens r>format_alignmentr0Ds4KIFVG uzSCK-?S(6&5>+?+?+DDqHICOS(6&5>+?+?+DDqHICOc&k3v;/ &k&$$**a!c'**#)*a!c'**##F'#:;GGm_F##F'#:;Gs6%#4fU36GHIB 6AqCFCF#}++AU+;<}++AU+;< q;!y. MM-..s%.@ A  6 MM-..s%.@ A WWY# c!1 MM-..s%.@ A MM-..s%.@ AB  NNZay+, 99bggg&9IJ KK1+*s  J: J?rG)rrz\Import of C module failed. Falling back to pure Python implementation. This may be slooow...__main__) run_doctest)F)%r4r} collectionsrBiorr Bio.Alignrr~rrr rhrrrrrrrr _PRECISIONrrWrXrZrrr0_python_make_score_matrix_fast _python_rint cpairwise2 ImportErrorr2 Bio._utilsr2rCrjr>r<s/CJ"+ +  G  {%D F ^,^,B upp2fR2B E)P06.6 6>r !$ &//4  ,  EL\"9 9 z&MHMM 0sB;;CC