Back to index

python-biopython  1.60
Public Member Functions
test_NCBIXML.TestNCBIXML Class Reference

List of all members.

Public Member Functions

def test_xbt001
def test_xbt002
def test_xbt003
def test_xbt004
def test_xbt005
def test_xbt006
def test_xbt007
def test_xbt008
def test_xbt009
def test_xbt010
def test_xbt011

Detailed Description

Definition at line 12 of file test_NCBIXML.py.


Member Function Documentation

Definition at line 14 of file test_NCBIXML.py.

00014 
00015     def test_xbt001(self):
00016         "Parsing BLASTP 2.2.12, gi|49176427|ref|NP_418280.3| (xbt001)"
00017 
00018         filename = 'xbt001.xml'
00019         datafile = os.path.join("Blast", filename)
00020         handle = open(datafile)
00021         records = NCBIXML.parse(handle)
00022         record = records.next()
00023 
00024         alignments = record.alignments
00025         self.assertEqual(len(alignments), 212)
00026         self.assertEqual(record.query_id, "gi|49176427|ref|NP_418280.3|")
00027         self.assertEqual(sum([len(a.hsps) for a in alignments]), 212)
00028 
00029         alignment = alignments[0]
00030         self.assertEqual(alignment.title[:50], "gi|49176427|ref|NP_418280.3| component of Sec-inde")
00031         self.assertEqual(alignment.length, 103)
00032         self.assertEqual(len(alignment.hsps), 1)
00033         hsp = alignment.hsps[0]
00034         self.assertTrue(hsp.expect, 4.20576e-46)
00035         self.assertEqual(hsp.query[:75], "MRLCLIIIYHRGTCMGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00036         self.assertEqual(hsp.match[:75], "MRLCLIIIYHRGTCMGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00037         self.assertEqual(hsp.sbjct[:75], "MRLCLIIIYHRGTCMGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00038 
00039         alignment = alignments[1]
00040         self.assertEqual(alignment.title[:50], "gi|15804428|ref|NP_290468.1| twin arginine translo")
00041         self.assertEqual(alignment.length, 103)
00042         self.assertEqual(len(alignment.hsps), 1)
00043         hsp = alignment.hsps[0]
00044         self.assertTrue(hsp.expect, 2.72609e-45)
00045         self.assertEqual(hsp.query[:75], "MRLCLIIIYHRGTCMGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00046         self.assertEqual(hsp.match[:75], "MRLCLIIIYHR TCMGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00047         self.assertEqual(hsp.sbjct[:75], "MRLCLIIIYHRXTCMGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00048 
00049         alignment = alignments[2]
00050         self.assertEqual(alignment.title[:50], "gi|74314349|ref|YP_312768.1| hypothetical protein ")
00051         self.assertEqual(alignment.length, 103)
00052         self.assertEqual(len(alignment.hsps), 1)
00053         hsp = alignment.hsps[0]
00054         self.assertTrue(hsp.expect, 2.72609e-45)
00055         self.assertEqual(hsp.query[:75], "MRLCLIIIYHRGTCMGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00056         self.assertEqual(hsp.match[:75], "MR CLIIIYHRGTCMGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00057         self.assertEqual(hsp.sbjct[:75], "MRPCLIIIYHRGTCMGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTA")
00058 
00059         alignment = alignments[3]
00060         self.assertEqual(alignment.title[:50], "gi|75256240|ref|ZP_00727918.1| COG1826: Sec-indepe")
00061         self.assertEqual(alignment.length, 89)
00062         self.assertEqual(len(alignment.hsps), 1)
00063         hsp = alignment.hsps[0]
00064         self.assertTrue(hsp.expect, 6.0872e-37)
00065         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00066         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00067         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00068 
00069         alignment = alignments[4]
00070         self.assertEqual(alignment.title[:50], "gi|148236|gb|AAA67633.1| o261 [Escherichia coli]")
00071         self.assertEqual(alignment.length, 261)
00072         self.assertEqual(len(alignment.hsps), 1)
00073         hsp = alignment.hsps[0]
00074         self.assertTrue(hsp.expect, 6.74582e-28)
00075         self.assertEqual(hsp.query[:75], "FGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQAKTEDA")
00076         self.assertEqual(hsp.match[:75], "FGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQAKTEDA")
00077         self.assertEqual(hsp.sbjct[:75], "FGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQAKTEDA")
00078 
00079         alignment = alignments[5]
00080         self.assertEqual(alignment.title[:50], "gi|29143650|ref|NP_806992.1| sec-independent prote")
00081         self.assertEqual(alignment.length, 84)
00082         self.assertEqual(len(alignment.hsps), 1)
00083         hsp = alignment.hsps[0]
00084         self.assertTrue(hsp.expect, 4.37251e-27)
00085         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00086         self.assertEqual(hsp.match[:75], "MGGISIWQLLI+AVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDD+ KQDKTSQDADFTAK+IADKQ      +")
00087         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIVAVIVVLLFGTKKLGSIGSDLGASIKGFKKAMSDDDAKQDKTSQDADFTAKSIADKQG-----E")
00088 
00089         alignment = alignments[6]
00090         self.assertEqual(alignment.title[:50], "gi|49609685|emb|CAG73118.1| sec-independent protei")
00091         self.assertEqual(alignment.length, 86)
00092         self.assertEqual(len(alignment.hsps), 1)
00093         hsp = alignment.hsps[0]
00094         self.assertTrue(hsp.expect, 4.10205e-17)
00095         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEP--KQDKTSQDADFTAKTIADKQADTNQ")
00096         self.assertEqual(hsp.match[:75], "MGGIS+W LLIIAVIV+LLFGT KL ++GSDLGASIKGFKKAM DD+P    DK   DADF+ K+IAD Q+D   ")
00097         self.assertEqual(hsp.sbjct[:75], "MGGISLWNLLIIAVIVILLFGTNKLRTLGSDLGASIKGFKKAMGDDQPSTNADKAQPDADFSTKSIADNQSD---")
00098 
00099         alignment = alignments[7]
00100         self.assertEqual(alignment.title[:50], "gi|37528238|ref|NP_931583.1| Sec-independent prote")
00101         self.assertEqual(alignment.length, 86)
00102         self.assertEqual(len(alignment.hsps), 1)
00103         hsp = alignment.hsps[0]
00104         self.assertTrue(hsp.expect, 2.25087e-15)
00105         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDD-EPKQ-DKTSQDADFTAKTIADKQADTNQ")
00106         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIAVIVVLLFGT KL ++GSDLGASIKGFKKA+ DD +P+Q  KTS DADF  K I +KQ+    ")
00107         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIAVIVVLLFGTNKLRTLGSDLGASIKGFKKAIGDDNQPQQAQKTSSDADFETKNITEKQS----")
00108 
00109         alignment = alignments[8]
00110         self.assertEqual(alignment.title[:50], "gi|59710656|ref|YP_203432.1| Sec-independent prote")
00111         self.assertEqual(alignment.length, 82)
00112         self.assertEqual(len(alignment.hsps), 1)
00113         hsp = alignment.hsps[0]
00114         self.assertTrue(hsp.expect, 5.01441e-15)
00115         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00116         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIAVI+VLLFGTKKL  +GSDLG+++KGFKKA+S+DEP ++   +DADF  + +  K+A+T ++Q")
00117         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIAVIIVLLFGTKKLRGVGSDLGSAVKGFKKAISEDEPAKE-AKKDADFVPQNLEKKEAETVEKQ")
00118 
00119         alignment = alignments[9]
00120         self.assertEqual(alignment.title[:50], "gi|54307340|ref|YP_128360.1| putative TatA protein")
00121         self.assertEqual(alignment.length, 87)
00122         self.assertEqual(len(alignment.hsps), 1)
00123         hsp = alignment.hsps[0]
00124         self.assertTrue(hsp.expect, 7.2408e-14)
00125         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDE--PKQDKTSQDADFTAKTIADKQADTNQ")
00126         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIA+I+VLLFGTKKL S+G DLG+++KGFKKA+ D+E   K+D T  DADF  KT++ ++  +  ")
00127         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIALIIVLLFGTKKLRSLGGDLGSAVKGFKKAIGDEELTVKKDNTEADADFEQKTLSKEEQQSED")
00128 
00129         alignment = alignments[10]
00130         self.assertEqual(alignment.title[:50], "gi|45437890|gb|AAS63439.1| Sec-independent protein")
00131         self.assertEqual(alignment.length, 88)
00132         self.assertEqual(len(alignment.hsps), 1)
00133         hsp = alignment.hsps[0]
00134         self.assertTrue(hsp.expect, 1.61308e-13)
00135         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDE----PKQDKTSQDADFTAKTIADKQADT")
00136         self.assertEqual(hsp.match[:75], "MG I   QLLIIAVIVVLLFGT KL ++GSDLGASIKGFKKAM DD        DKTS DADF AK+I +KQ   ")
00137         self.assertEqual(hsp.sbjct[:75], "MGSIGWAQLLIIAVIVVLLFGTNKLRTLGSDLGASIKGFKKAMGDDSQTPPTNVDKTSNDADF-AKSITEKQ---")
00138 
00139         alignment = alignments[11]
00140         self.assertEqual(alignment.title[:50], "gi|75856473|ref|ZP_00764101.1| COG1826: Sec-indepe")
00141         self.assertEqual(alignment.length, 81)
00142         self.assertEqual(len(alignment.hsps), 1)
00143         hsp = alignment.hsps[0]
00144         self.assertTrue(hsp.expect, 2.10675e-13)
00145         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00146         self.assertEqual(hsp.match[:75], "MGGIS+WQLLIIAVIVVLLFGTKKL  IG DLG ++KGFKKAMS+DEP   K  +DADF  K++ ++Q    +++")
00147         self.assertEqual(hsp.sbjct[:75], "MGGISVWQLLIIAVIVVLLFGTKKLRGIGGDLGGAVKGFKKAMSEDEPA--KNDKDADFEPKSLEEQQ----KKE")
00148 
00149         alignment = alignments[12]
00150         self.assertEqual(alignment.title[:50], "gi|75829371|ref|ZP_00758676.1| COG1826: Sec-indepe")
00151         self.assertEqual(alignment.length, 82)
00152         self.assertEqual(len(alignment.hsps), 1)
00153         hsp = alignment.hsps[0]
00154         self.assertTrue(hsp.expect, 2.7515e-13)
00155         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00156         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIAVIVVLLFGTKKL  IGSDLG+++KGFKKAMS++E       +DADF  K         N EQ")
00157         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIAVIVVLLFGTKKLRGIGSDLGSAVKGFKKAMSEEESNSAANQKDADFETK---------NLEQ")
00158 
00159         alignment = alignments[13]
00160         self.assertEqual(alignment.title[:50], "gi|75820019|ref|ZP_00750077.1| COG1826: Sec-indepe")
00161         self.assertEqual(alignment.length, 82)
00162         self.assertEqual(len(alignment.hsps), 1)
00163         hsp = alignment.hsps[0]
00164         self.assertTrue(hsp.expect, 3.59357e-13)
00165         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00166         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIAVIVVLLFGTKKL  IGSDLG+++KGFKKAMS++E       +DADF  K         N EQ")
00167         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIAVIVVLLFGTKKLRGIGSDLGSAVKGFKKAMSEEESNSAANQKDADFETK---------NLEQ")
00168 
00169         alignment = alignments[14]
00170         self.assertEqual(alignment.title[:50], "gi|28896872|ref|NP_796477.1| TatA protein [Vibrio ")
00171         self.assertEqual(alignment.length, 81)
00172         self.assertEqual(len(alignment.hsps), 1)
00173         hsp = alignment.hsps[0]
00174         self.assertTrue(hsp.expect, 2.32928e-12)
00175         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00176         self.assertEqual(hsp.match[:75], "MGGIS+WQLLIIAVIVVLLFGTKKL  IG DLG+++KGFKKAMSD++    K  +DADF  K++  +Q    Q++")
00177         self.assertEqual(hsp.sbjct[:75], "MGGISVWQLLIIAVIVVLLFGTKKLRGIGGDLGSAVKGFKKAMSDED--SAKNEKDADFEPKSLEKQQ----QKE")
00178 
00179         alignment = alignments[15]
00180         self.assertEqual(alignment.title[:50], "gi|27364353|ref|NP_759881.1| Sec-independent prote")
00181         self.assertEqual(alignment.length, 78)
00182         self.assertEqual(len(alignment.hsps), 1)
00183         hsp = alignment.hsps[0]
00184         self.assertTrue(hsp.expect, 3.97316e-12)
00185         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00186         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIAVIVVLLFGTKKL  IGSDLG +IKGFKKAM+++E ++    +DADF  K++     +   +Q")
00187         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIAVIVVLLFGTKKLRGIGSDLGGAIKGFKKAMNEEESEK----KDADFEPKSL-----EQQSKQ")
00188 
00189         alignment = alignments[16]
00190         self.assertEqual(alignment.title[:50], "gi|37678364|ref|NP_932973.1| Sec-independent prote")
00191         self.assertEqual(alignment.length, 78)
00192         self.assertEqual(len(alignment.hsps), 1)
00193         hsp = alignment.hsps[0]
00194         self.assertTrue(hsp.expect, 3.97316e-12)
00195         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00196         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIAVIVVLLFGTKKL  IGSDLG +IKGFKKAM+++E ++    +DADF  K++     +   +Q")
00197         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIAVIVVLLFGTKKLRGIGSDLGGAIKGFKKAMNEEESEK----KDADFEPKSL-----EQQNKQ")
00198 
00199         alignment = alignments[17]
00200         self.assertEqual(alignment.title[:50], "gi|71277787|ref|YP_266931.1| Sec-independent prote")
00201         self.assertEqual(alignment.length, 85)
00202         self.assertEqual(len(alignment.hsps), 1)
00203         hsp = alignment.hsps[0]
00204         self.assertTrue(hsp.expect, 3.97316e-12)
00205         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00206         self.assertEqual(hsp.match[:75], "MGGI IWQL+I+AVIVVLLFGTKKL +IG DLG++IKGFK A+ +D  K+ K S  A+ T+ T+AD    T +E ")
00207         self.assertEqual(hsp.sbjct[:75], "MGGIGIWQLVIVAVIVVLLFGTKKLRNIGGDLGSAIKGFKSAIGED--KEQKNS--AEKTSDTLADSSKSTTEEV")
00208 
00209         alignment = alignments[18]
00210         self.assertEqual(alignment.title[:50], "gi|68541995|ref|ZP_00581733.1| Twin-arginine trans")
00211         self.assertEqual(alignment.length, 79)
00212         self.assertEqual(len(alignment.hsps), 1)
00213         hsp = alignment.hsps[0]
00214         self.assertTrue(hsp.expect, 2.57533e-11)
00215         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKT---IADKQADTN")
00216         self.assertEqual(hsp.match[:75], "MGGISIWQLLI+A+IVVLLFGTKKL S+G DLG ++KGFK AMS +E K+     +A  TA+T     +K+ ++N")
00217         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIVALIVVLLFGTKKLRSLGGDLGGAVKGFKNAMSSEEDKKALEDTEAAKTAQTTQQATEKKPESN")
00218 
00219         alignment = alignments[19]
00220         self.assertEqual(alignment.title[:50], "gi|77813363|ref|ZP_00812641.1| Twin-arginine trans")
00221         self.assertEqual(alignment.length, 79)
00222         self.assertEqual(len(alignment.hsps), 1)
00223         hsp = alignment.hsps[0]
00224         self.assertTrue(hsp.expect, 2.57533e-11)
00225         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKT---IADKQADTN")
00226         self.assertEqual(hsp.match[:75], "MGGISIWQLLIIA+IVVLLFGTKKL S+G DLG ++KGFK AMS +E K+     +A  TA+T     +K+ ++N")
00227         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIALIVVLLFGTKKLRSLGGDLGGAVKGFKNAMSSEEDKKALEDTEAAKTAQTTQQATEKKPESN")
00228 
00229         alignment = alignments[20]
00230         self.assertEqual(alignment.title[:50], "gi|52306607|gb|AAU37107.1| TatA protein [Mannheimi")
00231         self.assertEqual(alignment.length, 75)
00232         self.assertEqual(len(alignment.hsps), 1)
00233         hsp = alignment.hsps[0]
00234         self.assertTrue(hsp.expect, 3.36348e-11)
00235         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00236         self.assertEqual(hsp.match[:75], "MGGISIWQLLII  I+VLLFGTKKL ++G+DLG S+KGFKKAM++DEPK      DA+F +    D+ A    E+")
00237         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIVAIIVLLFGTKKLRTLGTDLGESVKGFKKAMNEDEPK------DAEFKSLN-KDESATAGSEK")
00238 
00239         alignment = alignments[21]
00240         self.assertEqual(alignment.title[:50], "gi|75429751|ref|ZP_00732413.1| sec-independent pro")
00241         self.assertEqual(alignment.length, 74)
00242         self.assertEqual(len(alignment.hsps), 1)
00243         hsp = alignment.hsps[0]
00244         self.assertTrue(hsp.expect, 3.36348e-11)
00245         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00246         self.assertEqual(hsp.match[:75], "MGGISIWQLLII  IVVLLFGTKKL ++GSDLG S+KGFKKAM+ +EPK      DA+F +   A+  A T +E+")
00247         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIVAIVVLLFGTKKLRTLGSDLGESVKGFKKAMA-EEPK------DAEFKSLDKAENTAQTKKEE")
00248 
00249         alignment = alignments[22]
00250         self.assertEqual(alignment.title[:50], "gi|32033565|ref|ZP_00133892.1| COG1826: Sec-indepe")
00251         self.assertEqual(alignment.length, 76)
00252         self.assertEqual(len(alignment.hsps), 1)
00253         hsp = alignment.hsps[0]
00254         self.assertTrue(hsp.expect, 7.49305e-11)
00255         self.assertEqual(hsp.query[:75], "MGGISIWQXXXXXXXXXXXFGTKKLGSIGSDLGASIKGFKKAMSDDEPKQDKTSQDADFTAKTIADKQADTNQEQ")
00256         self.assertEqual(hsp.match[:75], "MGGISIWQLLII  I+VLLFGTKKL ++G+DLG S+KGFKKAM+DD+      SQ  D + + +  K+A + +++")
00257         self.assertEqual(hsp.sbjct[:75], "MGGISIWQLLIIVAIIVLLFGTKKLRTLGTDLGESVKGFKKAMADDK------SQPQDASFEKVEAKEAASTEQK")
00258 
00259         alignment = alignments[23]
00260         self.assertEqual(alignment.title[:50], "gi|12722097|gb|AAK03773.1| unknown [Pasteurella mu")
00261         self.assertEqual(alignment.length, 76)
00262         self.assertEqual(len(alignment.hsps), 1)
00263         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00264 
00265         alignment = alignments[24]
00266         self.assertEqual(alignment.title[:50], "gi|68546478|ref|ZP_00586025.1| Twin-arginine trans")
00267         self.assertEqual(alignment.length, 77)
00268         self.assertEqual(len(alignment.hsps), 1)
00269         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00270 
00271         alignment = alignments[25]
00272         self.assertEqual(alignment.title[:50], "gi|33151888|ref|NP_873241.1| sec-independent prote")
00273         self.assertEqual(alignment.length, 74)
00274         self.assertEqual(len(alignment.hsps), 1)
00275         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00276 
00277         alignment = alignments[26]
00278         self.assertEqual(alignment.title[:50], "gi|24375687|ref|NP_719730.1| Sec-independent prote")
00279         self.assertEqual(alignment.length, 88)
00280         self.assertEqual(len(alignment.hsps), 1)
00281         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00282 
00283         alignment = alignments[27]
00284         self.assertEqual(alignment.title[:50], "gi|71278553|ref|YP_269744.1| Sec-independent prote")
00285         self.assertEqual(alignment.length, 79)
00286         self.assertEqual(len(alignment.hsps), 1)
00287         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00288 
00289         alignment = alignments[28]
00290         self.assertEqual(alignment.title[:50], "gi|69159855|gb|EAN71956.1| Twin-arginine transloca")
00291         self.assertEqual(alignment.length, 79)
00292         self.assertEqual(len(alignment.hsps), 1)
00293         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00294 
00295         alignment = alignments[29]
00296         self.assertEqual(alignment.title[:50], "gi|69949858|ref|ZP_00637822.1| Twin-arginine trans")
00297         self.assertEqual(alignment.length, 81)
00298         self.assertEqual(len(alignment.hsps), 1)
00299         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00300 
00301         alignment = alignments[30]
00302         self.assertEqual(alignment.title[:50], "gi|48863844|ref|ZP_00317737.1| hypothetical protei")
00303         self.assertEqual(alignment.length, 83)
00304         self.assertEqual(len(alignment.hsps), 1)
00305         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00306 
00307         alignment = alignments[31]
00308         self.assertEqual(alignment.title[:50], "gi|77361831|ref|YP_341406.1| twin-arginine translo")
00309         self.assertEqual(alignment.length, 82)
00310         self.assertEqual(len(alignment.hsps), 1)
00311         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00312 
00313         alignment = alignments[32]
00314         self.assertEqual(alignment.title[:50], "gi|67676224|ref|ZP_00472975.1| Twin-arginine trans")
00315         self.assertEqual(alignment.length, 90)
00316         self.assertEqual(len(alignment.hsps), 1)
00317         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00318 
00319         alignment = alignments[33]
00320         self.assertEqual(alignment.title[:50], "gi|74317722|ref|YP_315462.1| twin-arginine translo")
00321         self.assertEqual(alignment.length, 70)
00322         self.assertEqual(len(alignment.hsps), 1)
00323         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00324 
00325         alignment = alignments[34]
00326         self.assertEqual(alignment.title[:50], "gi|77166504|ref|YP_345029.1| Twin-arginine translo")
00327         self.assertEqual(alignment.length, 90)
00328         self.assertEqual(len(alignment.hsps), 1)
00329         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00330 
00331         alignment = alignments[35]
00332         self.assertEqual(alignment.title[:50], "gi|16128610|ref|NP_415160.1| component of Sec-inde")
00333         self.assertEqual(alignment.length, 67)
00334         self.assertEqual(len(alignment.hsps), 1)
00335         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00336 
00337         alignment = alignments[36]
00338         self.assertEqual(alignment.title[:50], "gi|12831974|emb|CAC29147.1| TatA protein [Pseudomo")
00339         self.assertEqual(alignment.length, 76)
00340         self.assertEqual(len(alignment.hsps), 1)
00341         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00342 
00343         alignment = alignments[37]
00344         self.assertEqual(alignment.title[:50], "gi|32029972|ref|ZP_00132908.1| COG1826: Sec-indepe")
00345         self.assertEqual(alignment.length, 73)
00346         self.assertEqual(len(alignment.hsps), 1)
00347         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00348 
00349         alignment = alignments[38]
00350         self.assertEqual(alignment.title[:50], "gi|455172|gb|AAA24073.1| ORF; putative")
00351         self.assertEqual(alignment.length, 67)
00352         self.assertEqual(len(alignment.hsps), 1)
00353         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00354 
00355         alignment = alignments[39]
00356         self.assertEqual(alignment.title[:50], "gi|1224007|gb|AAA92108.1| ORF4")
00357         self.assertEqual(alignment.length, 192)
00358         self.assertEqual(len(alignment.hsps), 1)
00359         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00360 
00361         alignment = alignments[40]
00362         self.assertEqual(alignment.title[:50], "gi|68056990|gb|AAX87243.1| Sec-independent protein")
00363         self.assertEqual(alignment.length, 95)
00364         self.assertEqual(len(alignment.hsps), 1)
00365         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00366 
00367         alignment = alignments[41]
00368         self.assertEqual(alignment.title[:50], "gi|56461470|ref|YP_156751.1| Sec-independent prote")
00369         self.assertEqual(alignment.length, 73)
00370         self.assertEqual(len(alignment.hsps), 1)
00371         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00372 
00373         alignment = alignments[42]
00374         self.assertEqual(alignment.title[:50], "gi|76793313|ref|ZP_00775802.1| Twin-arginine trans")
00375         self.assertEqual(alignment.length, 84)
00376         self.assertEqual(len(alignment.hsps), 1)
00377         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00378 
00379         alignment = alignments[43]
00380         self.assertEqual(alignment.title[:50], "gi|42630489|ref|ZP_00156028.1| COG1826: Sec-indepe")
00381         self.assertEqual(alignment.length, 75)
00382         self.assertEqual(len(alignment.hsps), 1)
00383         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00384 
00385         alignment = alignments[44]
00386         self.assertEqual(alignment.title[:50], "gi|1074302|pir||B64145 hypothetical protein HI0187")
00387         self.assertEqual(alignment.length, 109)
00388         self.assertEqual(len(alignment.hsps), 1)
00389         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00390 
00391         alignment = alignments[45]
00392         self.assertEqual(alignment.title[:50], "gi|67641583|ref|ZP_00440359.1| COG1826: Sec-indepe")
00393         self.assertEqual(alignment.length, 77)
00394         self.assertEqual(len(alignment.hsps), 1)
00395         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00396 
00397         alignment = alignments[46]
00398         self.assertEqual(alignment.title[:50], "gi|67545726|ref|ZP_00423646.1| Twin-arginine trans")
00399         self.assertEqual(alignment.length, 76)
00400         self.assertEqual(len(alignment.hsps), 1)
00401         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00402 
00403         alignment = alignments[47]
00404         self.assertEqual(alignment.title[:50], "gi|45435806|gb|AAS61363.1| sec-independent protein")
00405         self.assertEqual(alignment.length, 85)
00406         self.assertEqual(len(alignment.hsps), 1)
00407         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00408 
00409         alignment = alignments[48]
00410         self.assertEqual(alignment.title[:50], "gi|49610761|emb|CAG74206.1| Sec-independent protei")
00411         self.assertEqual(alignment.length, 65)
00412         self.assertEqual(len(alignment.hsps), 1)
00413         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00414 
00415         alignment = alignments[49]
00416         self.assertEqual(alignment.title[:50], "gi|67663266|ref|ZP_00460549.1| Twin-arginine trans")
00417         self.assertEqual(alignment.length, 76)
00418         self.assertEqual(len(alignment.hsps), 1)
00419         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00420 
00421         alignment = alignments[50]
00422         self.assertEqual(alignment.title[:50], "gi|33594634|ref|NP_882278.1| Sec-independent prote")
00423         self.assertEqual(alignment.length, 75)
00424         self.assertEqual(len(alignment.hsps), 1)
00425         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00426 
00427         alignment = alignments[51]
00428         self.assertEqual(alignment.title[:50], "gi|46310681|ref|ZP_00211309.1| COG1826: Sec-indepe")
00429         self.assertEqual(alignment.length, 76)
00430         self.assertEqual(len(alignment.hsps), 1)
00431         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00432 
00433         alignment = alignments[52]
00434         self.assertEqual(alignment.title[:50], "gi|58584031|ref|YP_203047.1| sec-independent prote")
00435         self.assertEqual(alignment.length, 75)
00436         self.assertEqual(len(alignment.hsps), 1)
00437         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00438 
00439         alignment = alignments[53]
00440         self.assertEqual(alignment.title[:50], "gi|17429965|emb|CAD16649.1| PROBABLE SIGNAL PEPTID")
00441         self.assertEqual(alignment.length, 85)
00442         self.assertEqual(len(alignment.hsps), 1)
00443         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00444 
00445         alignment = alignments[54]
00446         self.assertEqual(alignment.title[:50], "gi|47573371|ref|ZP_00243410.1| COG1826: Sec-indepe")
00447         self.assertEqual(alignment.length, 76)
00448         self.assertEqual(len(alignment.hsps), 1)
00449         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00450 
00451         alignment = alignments[55]
00452         self.assertEqual(alignment.title[:50], "gi|16273687|ref|NP_438355.1| Sec-independent prote")
00453         self.assertEqual(alignment.length, 89)
00454         self.assertEqual(len(alignment.hsps), 1)
00455         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00456 
00457         alignment = alignments[56]
00458         self.assertEqual(alignment.title[:50], "gi|73542784|ref|YP_297304.1| Twin-arginine translo")
00459         self.assertEqual(alignment.length, 73)
00460         self.assertEqual(len(alignment.hsps), 1)
00461         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00462 
00463         alignment = alignments[57]
00464         self.assertEqual(alignment.title[:50], "gi|26987777|ref|NP_743202.1| Sec-independent prote")
00465         self.assertEqual(alignment.length, 77)
00466         self.assertEqual(len(alignment.hsps), 1)
00467         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00468 
00469         alignment = alignments[58]
00470         self.assertEqual(alignment.title[:50], "gi|29142636|ref|NP_805978.1| sec-independent prote")
00471         self.assertEqual(alignment.length, 67)
00472         self.assertEqual(len(alignment.hsps), 1)
00473         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00474 
00475         alignment = alignments[59]
00476         self.assertEqual(alignment.title[:50], "gi|18389921|gb|AAL68797.1| TatA [Ralstonia eutroph")
00477         self.assertEqual(alignment.length, 77)
00478         self.assertEqual(len(alignment.hsps), 1)
00479         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00480 
00481         alignment = alignments[60]
00482         self.assertEqual(alignment.title[:50], "gi|48781637|ref|ZP_00278228.1| COG1826: Sec-indepe")
00483         self.assertEqual(alignment.length, 79)
00484         self.assertEqual(len(alignment.hsps), 1)
00485         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00486 
00487         alignment = alignments[61]
00488         self.assertEqual(alignment.title[:50], "gi|77456610|ref|YP_346115.1| Twin-arginine translo")
00489         self.assertEqual(alignment.length, 92)
00490         self.assertEqual(len(alignment.hsps), 1)
00491         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00492 
00493         alignment = alignments[62]
00494         self.assertEqual(alignment.title[:50], "gi|1684735|emb|CAA98158.1| ORF57 protein [Pseudomo")
00495         self.assertEqual(alignment.length, 57)
00496         self.assertEqual(len(alignment.hsps), 1)
00497         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00498 
00499         alignment = alignments[63]
00500         self.assertEqual(alignment.title[:50], "gi|56476124|ref|YP_157713.1| Sec-independent prote")
00501         self.assertEqual(alignment.length, 75)
00502         self.assertEqual(len(alignment.hsps), 1)
00503         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00504 
00505         alignment = alignments[64]
00506         self.assertEqual(alignment.title[:50], "gi|34496078|ref|NP_900293.1| Sec-independent prote")
00507         self.assertEqual(alignment.length, 68)
00508         self.assertEqual(len(alignment.hsps), 1)
00509         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00510 
00511         alignment = alignments[65]
00512         self.assertEqual(alignment.title[:50], "gi|67848115|ref|ZP_00503233.1| Twin-arginine trans")
00513         self.assertEqual(alignment.length, 83)
00514         self.assertEqual(len(alignment.hsps), 1)
00515         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00516 
00517         alignment = alignments[66]
00518         self.assertEqual(alignment.title[:50], "gi|26991692|ref|NP_747117.1| Sec-independent prote")
00519         self.assertEqual(alignment.length, 90)
00520         self.assertEqual(len(alignment.hsps), 1)
00521         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00522 
00523         alignment = alignments[67]
00524         self.assertEqual(alignment.title[:50], "gi|15601293|ref|NP_232924.1| tatA protein [Vibrio ")
00525         self.assertEqual(alignment.length, 78)
00526         self.assertEqual(len(alignment.hsps), 1)
00527         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00528 
00529         alignment = alignments[68]
00530         self.assertEqual(alignment.title[:50], "gi|66770480|ref|YP_245242.1| sec-independent prote")
00531         self.assertEqual(alignment.length, 75)
00532         self.assertEqual(len(alignment.hsps), 1)
00533         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00534 
00535         alignment = alignments[69]
00536         self.assertEqual(alignment.title[:50], "gi|53804435|ref|YP_113945.1| Sec-independent prote")
00537         self.assertEqual(alignment.length, 70)
00538         self.assertEqual(len(alignment.hsps), 1)
00539         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00540 
00541         alignment = alignments[70]
00542         self.assertEqual(alignment.title[:50], "gi|75825357|ref|ZP_00754793.1| COG1826: Sec-indepe")
00543         self.assertEqual(alignment.length, 80)
00544         self.assertEqual(len(alignment.hsps), 1)
00545         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00546 
00547         alignment = alignments[71]
00548         self.assertEqual(alignment.title[:50], "gi|71908987|ref|YP_286574.1| Twin-arginine translo")
00549         self.assertEqual(alignment.length, 76)
00550         self.assertEqual(len(alignment.hsps), 1)
00551         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00552 
00553         alignment = alignments[72]
00554         self.assertEqual(alignment.title[:50], "gi|68526571|gb|EAN49542.1| Twin-arginine transloca")
00555         self.assertEqual(alignment.length, 77)
00556         self.assertEqual(len(alignment.hsps), 1)
00557         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00558 
00559         alignment = alignments[73]
00560         self.assertEqual(alignment.title[:50], "gi|71736448|ref|YP_272670.1| sec-independent prote")
00561         self.assertEqual(alignment.length, 91)
00562         self.assertEqual(len(alignment.hsps), 1)
00563         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00564 
00565         alignment = alignments[74]
00566         self.assertEqual(alignment.title[:50], "gi|56460344|ref|YP_155625.1| Sec-independent prote")
00567         self.assertEqual(alignment.length, 72)
00568         self.assertEqual(len(alignment.hsps), 1)
00569         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00570 
00571         alignment = alignments[75]
00572         self.assertEqual(alignment.title[:50], "gi|68214708|ref|ZP_00566522.1| Twin-arginine trans")
00573         self.assertEqual(alignment.length, 72)
00574         self.assertEqual(len(alignment.hsps), 1)
00575         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00576 
00577         alignment = alignments[76]
00578         self.assertEqual(alignment.title[:50], "gi|30248650|ref|NP_840720.1| mttA/Hcf106 family [N")
00579         self.assertEqual(alignment.length, 76)
00580         self.assertEqual(len(alignment.hsps), 1)
00581         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00582 
00583         alignment = alignments[77]
00584         self.assertEqual(alignment.title[:50], "gi|75822907|ref|ZP_00752458.1| COG1826: Sec-indepe")
00585         self.assertEqual(alignment.length, 78)
00586         self.assertEqual(len(alignment.hsps), 1)
00587         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00588 
00589         alignment = alignments[78]
00590         self.assertEqual(alignment.title[:50], "gi|70733926|ref|YP_257566.1| sec-independent prote")
00591         self.assertEqual(alignment.length, 93)
00592         self.assertEqual(len(alignment.hsps), 1)
00593         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00594 
00595         alignment = alignments[79]
00596         self.assertEqual(alignment.title[:50], "gi|63254358|gb|AAY35454.1| Twin-arginine transloca")
00597         self.assertEqual(alignment.length, 91)
00598         self.assertEqual(len(alignment.hsps), 1)
00599         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00600 
00601         alignment = alignments[80]
00602         self.assertEqual(alignment.title[:50], "gi|73354814|gb|AAZ75668.1| TatA [Pseudomonas syrin")
00603         self.assertEqual(alignment.length, 91)
00604         self.assertEqual(len(alignment.hsps), 1)
00605         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00606 
00607         alignment = alignments[81]
00608         self.assertEqual(alignment.title[:50], "gi|50083761|ref|YP_045271.1| Sec-independent prote")
00609         self.assertEqual(alignment.length, 78)
00610         self.assertEqual(len(alignment.hsps), 1)
00611         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00612 
00613         alignment = alignments[82]
00614         self.assertEqual(alignment.title[:50], "gi|71548504|ref|ZP_00668728.1| Twin-arginine trans")
00615         self.assertEqual(alignment.length, 77)
00616         self.assertEqual(len(alignment.hsps), 1)
00617         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00618 
00619         alignment = alignments[83]
00620         self.assertEqual(alignment.title[:50], "gi|55247002|gb|EAL42253.1| ENSANGP00000028218 [Ano")
00621         self.assertEqual(alignment.length, 53)
00622         self.assertEqual(len(alignment.hsps), 1)
00623         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00624 
00625         alignment = alignments[84]
00626         self.assertEqual(alignment.title[:50], "gi|50084688|ref|YP_046198.1| Sec-independent prote")
00627         self.assertEqual(alignment.length, 71)
00628         self.assertEqual(len(alignment.hsps), 1)
00629         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00630 
00631         alignment = alignments[85]
00632         self.assertEqual(alignment.title[:50], "gi|28872267|ref|NP_794886.1| sec-independent prote")
00633         self.assertEqual(alignment.length, 91)
00634         self.assertEqual(len(alignment.hsps), 1)
00635         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00636 
00637         alignment = alignments[86]
00638         self.assertEqual(alignment.title[:50], "gi|49082486|gb|AAT50643.1| PA5068 [synthetic const")
00639         self.assertEqual(alignment.length, 83)
00640         self.assertEqual(len(alignment.hsps), 1)
00641         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00642 
00643         alignment = alignments[87]
00644         self.assertEqual(alignment.title[:50], "gi|53726598|ref|ZP_00141543.2| COG1826: Sec-indepe")
00645         self.assertEqual(alignment.length, 82)
00646         self.assertEqual(len(alignment.hsps), 1)
00647         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00648 
00649         alignment = alignments[88]
00650         self.assertEqual(alignment.title[:50], "gi|68213616|ref|ZP_00565447.1| Twin-arginine trans")
00651         self.assertEqual(alignment.length, 54)
00652         self.assertEqual(len(alignment.hsps), 1)
00653         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00654 
00655         alignment = alignments[89]
00656         self.assertEqual(alignment.title[:50], "gi|74023810|ref|ZP_00694377.1| Twin-arginine trans")
00657         self.assertEqual(alignment.length, 79)
00658         self.assertEqual(len(alignment.hsps), 1)
00659         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00660 
00661         alignment = alignments[90]
00662         self.assertEqual(alignment.title[:50], "gi|71066554|ref|YP_265281.1| twin-arginine translo")
00663         self.assertEqual(alignment.length, 87)
00664         self.assertEqual(len(alignment.hsps), 1)
00665         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00666 
00667         alignment = alignments[91]
00668         self.assertEqual(alignment.title[:50], "gi|15611372|ref|NP_223023.1| hypothetical protein ")
00669         self.assertEqual(alignment.length, 79)
00670         self.assertEqual(len(alignment.hsps), 1)
00671         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00672 
00673         alignment = alignments[92]
00674         self.assertEqual(alignment.title[:50], "gi|13471183|ref|NP_102752.1| sec-independent prote")
00675         self.assertEqual(alignment.length, 73)
00676         self.assertEqual(len(alignment.hsps), 1)
00677         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00678 
00679         alignment = alignments[93]
00680         self.assertEqual(alignment.title[:50], "gi|42523995|ref|NP_969375.1| twin-arginine-depende")
00681         self.assertEqual(alignment.length, 81)
00682         self.assertEqual(len(alignment.hsps), 1)
00683         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00684 
00685         alignment = alignments[94]
00686         self.assertEqual(alignment.title[:50], "gi|67158086|ref|ZP_00419176.1| Twin-arginine trans")
00687         self.assertEqual(alignment.length, 85)
00688         self.assertEqual(len(alignment.hsps), 1)
00689         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00690 
00691         alignment = alignments[95]
00692         self.assertEqual(alignment.title[:50], "gi|15644948|ref|NP_207118.1| conserved hypothetica")
00693         self.assertEqual(alignment.length, 79)
00694         self.assertEqual(len(alignment.hsps), 1)
00695         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00696 
00697         alignment = alignments[96]
00698         self.assertEqual(alignment.title[:50], "gi|13277311|emb|CAC34414.1| putative TatA protein ")
00699         self.assertEqual(alignment.length, 61)
00700         self.assertEqual(len(alignment.hsps), 1)
00701         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00702 
00703         alignment = alignments[97]
00704         self.assertEqual(alignment.title[:50], "gi|54298906|ref|YP_125275.1| Putative TatA protein")
00705         self.assertEqual(alignment.length, 61)
00706         self.assertEqual(len(alignment.hsps), 1)
00707         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00708 
00709         alignment = alignments[98]
00710         self.assertEqual(alignment.title[:50], "gi|71363513|ref|ZP_00654157.1| Twin-arginine trans")
00711         self.assertEqual(alignment.length, 94)
00712         self.assertEqual(len(alignment.hsps), 1)
00713         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00714 
00715         alignment = alignments[99]
00716         self.assertEqual(alignment.title[:50], "gi|71362217|ref|ZP_00653377.1| Twin-arginine trans")
00717         self.assertEqual(alignment.length, 80)
00718         self.assertEqual(len(alignment.hsps), 1)
00719         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00720 
00721         alignment = alignments[100]
00722         self.assertEqual(alignment.title[:50], "gi|27379862|ref|NP_771391.1| hypothetical protein ")
00723         self.assertEqual(alignment.length, 77)
00724         self.assertEqual(len(alignment.hsps), 1)
00725         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00726 
00727         alignment = alignments[101]
00728         self.assertEqual(alignment.title[:50], "gi|39935914|ref|NP_948190.1| putative sec-independ")
00729         self.assertEqual(alignment.length, 78)
00730         self.assertEqual(len(alignment.hsps), 1)
00731         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00732 
00733         alignment = alignments[102]
00734         self.assertEqual(alignment.title[:50], "gi|17935600|ref|NP_532390.1| SEC-independent prote")
00735         self.assertEqual(alignment.length, 70)
00736         self.assertEqual(len(alignment.hsps), 1)
00737         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00738 
00739         alignment = alignments[103]
00740         self.assertEqual(alignment.title[:50], "gi|62289827|ref|YP_221620.1| Sec-independent prote")
00741         self.assertEqual(alignment.length, 72)
00742         self.assertEqual(len(alignment.hsps), 1)
00743         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00744 
00745         alignment = alignments[104]
00746         self.assertEqual(alignment.title[:50], "gi|23347697|gb|AAN29810.1| Sec-independent protein")
00747         self.assertEqual(alignment.length, 80)
00748         self.assertEqual(len(alignment.hsps), 1)
00749         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00750 
00751         alignment = alignments[105]
00752         self.assertEqual(alignment.title[:50], "gi|75675971|ref|YP_318392.1| twin-arginine translo")
00753         self.assertEqual(alignment.length, 78)
00754         self.assertEqual(len(alignment.hsps), 1)
00755         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00756 
00757         alignment = alignments[106]
00758         self.assertEqual(alignment.title[:50], "gi|69928230|ref|ZP_00625391.1| Twin-arginine trans")
00759         self.assertEqual(alignment.length, 79)
00760         self.assertEqual(len(alignment.hsps), 1)
00761         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00762 
00763         alignment = alignments[107]
00764         self.assertEqual(alignment.title[:50], "gi|77689454|ref|ZP_00804635.1| Twin-arginine trans")
00765         self.assertEqual(alignment.length, 79)
00766         self.assertEqual(len(alignment.hsps), 1)
00767         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00768 
00769         alignment = alignments[108]
00770         self.assertEqual(alignment.title[:50], "gi|77743614|ref|ZP_00812071.1| Twin-arginine trans")
00771         self.assertEqual(alignment.length, 78)
00772         self.assertEqual(len(alignment.hsps), 1)
00773         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00774 
00775         alignment = alignments[109]
00776         self.assertEqual(alignment.title[:50], "gi|71066141|ref|YP_264868.1| twin-arginine translo")
00777         self.assertEqual(alignment.length, 89)
00778         self.assertEqual(len(alignment.hsps), 1)
00779         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00780 
00781         alignment = alignments[110]
00782         self.assertEqual(alignment.title[:50], "gi|28199457|ref|NP_779771.1| SEC-independent prote")
00783         self.assertEqual(alignment.length, 71)
00784         self.assertEqual(len(alignment.hsps), 1)
00785         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00786 
00787         alignment = alignments[111]
00788         self.assertEqual(alignment.title[:50], "gi|15837166|ref|NP_297854.1| hypothetical protein ")
00789         self.assertEqual(alignment.length, 71)
00790         self.assertEqual(len(alignment.hsps), 1)
00791         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00792 
00793         alignment = alignments[112]
00794         self.assertEqual(alignment.title[:50], "gi|15074462|emb|CAC46108.1| HYPOTHETICAL TRANSMEMB")
00795         self.assertEqual(alignment.length, 68)
00796         self.assertEqual(len(alignment.hsps), 1)
00797         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00798 
00799         alignment = alignments[113]
00800         self.assertEqual(alignment.title[:50], "gi|27462871|gb|AAO15625.1| Sec-independent protein")
00801         self.assertEqual(alignment.length, 63)
00802         self.assertEqual(len(alignment.hsps), 1)
00803         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00804 
00805         alignment = alignments[114]
00806         self.assertEqual(alignment.title[:50], "gi|35211273|dbj|BAC88652.1| gsl0711 [Gloeobacter v")
00807         self.assertEqual(alignment.length, 72)
00808         self.assertEqual(len(alignment.hsps), 1)
00809         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00810 
00811         alignment = alignments[115]
00812         self.assertEqual(alignment.title[:50], "gi|34482347|emb|CAE09348.1| hypothetical protein [")
00813         self.assertEqual(alignment.length, 80)
00814         self.assertEqual(len(alignment.hsps), 1)
00815         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00816 
00817         alignment = alignments[116]
00818         self.assertEqual(alignment.title[:50], "gi|32262257|gb|AAP77305.1| component of Sec-indepe")
00819         self.assertEqual(alignment.length, 82)
00820         self.assertEqual(len(alignment.hsps), 1)
00821         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00822 
00823         alignment = alignments[117]
00824         self.assertEqual(alignment.title[:50], "gi|76261408|ref|ZP_00769019.1| Twin-arginine trans")
00825         self.assertEqual(alignment.length, 62)
00826         self.assertEqual(len(alignment.hsps), 1)
00827         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00828 
00829         alignment = alignments[118]
00830         self.assertEqual(alignment.title[:50], "gi|69933726|ref|ZP_00628928.1| sec-independent tra")
00831         self.assertEqual(alignment.length, 159)
00832         self.assertEqual(len(alignment.hsps), 1)
00833         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00834 
00835         alignment = alignments[119]
00836         self.assertEqual(alignment.title[:50], "gi|15605662|ref|NP_213037.1| hypothetical protein ")
00837         self.assertEqual(alignment.length, 59)
00838         self.assertEqual(len(alignment.hsps), 1)
00839         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00840 
00841         alignment = alignments[120]
00842         self.assertEqual(alignment.title[:50], "gi|68538777|ref|ZP_00578553.1| Twin-arginine trans")
00843         self.assertEqual(alignment.length, 77)
00844         self.assertEqual(len(alignment.hsps), 1)
00845         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00846 
00847         alignment = alignments[121]
00848         self.assertEqual(alignment.title[:50], "gi|68136098|ref|ZP_00544086.1| Twin-arginine trans")
00849         self.assertEqual(alignment.length, 130)
00850         self.assertEqual(len(alignment.hsps), 1)
00851         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00852 
00853         alignment = alignments[122]
00854         self.assertEqual(alignment.title[:50], "gi|20259265|gb|AAM14368.1| putative Tha4 protein [")
00855         self.assertEqual(alignment.length, 147)
00856         self.assertEqual(len(alignment.hsps), 1)
00857         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00858 
00859         alignment = alignments[123]
00860         self.assertEqual(alignment.title[:50], "gi|75910646|ref|YP_324942.1| Twin-arginine translo")
00861         self.assertEqual(alignment.length, 90)
00862         self.assertEqual(len(alignment.hsps), 1)
00863         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00864 
00865         alignment = alignments[124]
00866         self.assertEqual(alignment.title[:50], "gi|39982657|gb|AAR34117.1| twin-arginine transloca")
00867         self.assertEqual(alignment.length, 57)
00868         self.assertEqual(len(alignment.hsps), 1)
00869         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00870 
00871         alignment = alignments[125]
00872         self.assertEqual(alignment.title[:50], "gi|33635687|emb|CAE22011.1| mttA/Hcf106 family [Pr")
00873         self.assertEqual(alignment.length, 91)
00874         self.assertEqual(len(alignment.hsps), 1)
00875         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00876 
00877         alignment = alignments[126]
00878         self.assertEqual(alignment.title[:50], "gi|76791934|ref|ZP_00774438.1| Twin-arginine trans")
00879         self.assertEqual(alignment.length, 68)
00880         self.assertEqual(len(alignment.hsps), 1)
00881         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00882 
00883         alignment = alignments[127]
00884         self.assertEqual(alignment.title[:50], "gi|23129516|ref|ZP_00111343.1| COG1826: Sec-indepe")
00885         self.assertEqual(alignment.length, 91)
00886         self.assertEqual(len(alignment.hsps), 1)
00887         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00888 
00889         alignment = alignments[128]
00890         self.assertEqual(alignment.title[:50], "gi|48764199|ref|ZP_00268751.1| COG1826: Sec-indepe")
00891         self.assertEqual(alignment.length, 96)
00892         self.assertEqual(len(alignment.hsps), 1)
00893         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00894 
00895         alignment = alignments[129]
00896         self.assertEqual(alignment.title[:50], "gi|15677995|ref|NP_273645.1| hypothetical protein ")
00897         self.assertEqual(alignment.length, 67)
00898         self.assertEqual(len(alignment.hsps), 1)
00899         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00900 
00901         alignment = alignments[130]
00902         self.assertEqual(alignment.title[:50], "gi|50917153|ref|XP_468973.1| putative sec-independ")
00903         self.assertEqual(alignment.length, 170)
00904         self.assertEqual(len(alignment.hsps), 1)
00905         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00906 
00907         alignment = alignments[131]
00908         self.assertEqual(alignment.title[:50], "gi|16329622|ref|NP_440350.1| hypothetical protein ")
00909         self.assertEqual(alignment.length, 126)
00910         self.assertEqual(len(alignment.hsps), 1)
00911         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00912 
00913         alignment = alignments[132]
00914         self.assertEqual(alignment.title[:50], "gi|71083667|ref|YP_266387.1| Twin-arginine translo")
00915         self.assertEqual(alignment.length, 66)
00916         self.assertEqual(len(alignment.hsps), 1)
00917         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00918 
00919         alignment = alignments[133]
00920         self.assertEqual(alignment.title[:50], "gi|17130190|dbj|BAB72802.1| asl0845 [Nostoc sp. PC")
00921         self.assertEqual(alignment.length, 90)
00922         self.assertEqual(len(alignment.hsps), 1)
00923         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00924 
00925         alignment = alignments[134]
00926         self.assertEqual(alignment.title[:50], "gi|68246031|gb|EAN28138.1| Twin-arginine transloca")
00927         self.assertEqual(alignment.length, 69)
00928         self.assertEqual(len(alignment.hsps), 1)
00929         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00930 
00931         alignment = alignments[135]
00932         self.assertEqual(alignment.title[:50], "gi|15604583|ref|NP_221101.1| hypothetical protein ")
00933         self.assertEqual(alignment.length, 54)
00934         self.assertEqual(len(alignment.hsps), 1)
00935         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00936 
00937         alignment = alignments[136]
00938         self.assertEqual(alignment.title[:50], "gi|77685166|ref|ZP_00800574.1| Twin-arginine trans")
00939         self.assertEqual(alignment.length, 69)
00940         self.assertEqual(len(alignment.hsps), 1)
00941         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00942 
00943         alignment = alignments[137]
00944         self.assertEqual(alignment.title[:50], "gi|39985226|gb|AAR36581.1| twin-arginine transloca")
00945         self.assertEqual(alignment.length, 78)
00946         self.assertEqual(len(alignment.hsps), 1)
00947         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00948 
00949         alignment = alignments[138]
00950         self.assertEqual(alignment.title[:50], "gi|1825636|gb|AAB42258.1| Hypothetical protein ZK3")
00951         self.assertEqual(alignment.length, 312)
00952         self.assertEqual(len(alignment.hsps), 1)
00953         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00954 
00955         alignment = alignments[139]
00956         self.assertEqual(alignment.title[:50], "gi|65321915|ref|ZP_00394874.1| COG5386: Cell surfa")
00957         self.assertEqual(alignment.length, 237)
00958         self.assertEqual(len(alignment.hsps), 1)
00959         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00960 
00961         alignment = alignments[140]
00962         self.assertEqual(alignment.title[:50], "gi|30022625|ref|NP_834256.1| Cell surface protein ")
00963         self.assertEqual(alignment.length, 237)
00964         self.assertEqual(len(alignment.hsps), 1)
00965         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00966 
00967         alignment = alignments[141]
00968         self.assertEqual(alignment.title[:50], "gi|55623442|ref|XP_517520.1| PREDICTED: similar to")
00969         self.assertEqual(alignment.length, 234)
00970         self.assertEqual(len(alignment.hsps), 1)
00971         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00972 
00973         alignment = alignments[142]
00974         self.assertEqual(alignment.title[:50], "gi|75762866|ref|ZP_00742681.1| Cell surface protei")
00975         self.assertEqual(alignment.length, 237)
00976         self.assertEqual(len(alignment.hsps), 1)
00977         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00978 
00979         alignment = alignments[143]
00980         self.assertEqual(alignment.title[:50], "gi|22945598|gb|AAN10511.1| CG18497-PC, isoform C [")
00981         self.assertEqual(alignment.length, 5476)
00982         self.assertEqual(len(alignment.hsps), 1)
00983         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00984 
00985         alignment = alignments[144]
00986         self.assertEqual(alignment.title[:50], "gi|10727420|gb|AAF51534.2| CG18497-PB, isoform B [")
00987         self.assertEqual(alignment.length, 5533)
00988         self.assertEqual(len(alignment.hsps), 1)
00989         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00990 
00991         alignment = alignments[145]
00992         self.assertEqual(alignment.title[:50], "gi|10727421|gb|AAF51535.2| CG18497-PA, isoform A [")
00993         self.assertEqual(alignment.length, 5560)
00994         self.assertEqual(len(alignment.hsps), 1)
00995         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
00996 
00997         alignment = alignments[146]
00998         self.assertEqual(alignment.title[:50], "gi|71481981|ref|ZP_00661682.1| Twin-arginine trans")
00999         self.assertEqual(alignment.length, 69)
01000         self.assertEqual(len(alignment.hsps), 1)
01001         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01002 
01003         alignment = alignments[147]
01004         self.assertEqual(alignment.title[:50], "gi|71150623|ref|ZP_00649545.1| Twin-arginine trans")
01005         self.assertEqual(alignment.length, 81)
01006         self.assertEqual(len(alignment.hsps), 1)
01007         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01008 
01009         alignment = alignments[148]
01010         self.assertEqual(alignment.title[:50], "gi|20151563|gb|AAM11141.1| LD15253p [Drosophila me")
01011         self.assertEqual(alignment.length, 1521)
01012         self.assertEqual(len(alignment.hsps), 1)
01013         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01014 
01015         alignment = alignments[149]
01016         self.assertEqual(alignment.title[:50], "gi|6979936|gb|AAF34661.1| split ends long isoform ")
01017         self.assertEqual(alignment.length, 5554)
01018         self.assertEqual(len(alignment.hsps), 1)
01019         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01020 
01021         alignment = alignments[150]
01022         self.assertEqual(alignment.title[:50], "gi|6467825|gb|AAF13218.1| Spen RNP motif protein l")
01023         self.assertEqual(alignment.length, 5533)
01024         self.assertEqual(len(alignment.hsps), 1)
01025         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01026 
01027         alignment = alignments[151]
01028         self.assertEqual(alignment.title[:50], "gi|61102013|ref|ZP_00377467.1| hypothetical protei")
01029         self.assertEqual(alignment.length, 80)
01030         self.assertEqual(len(alignment.hsps), 1)
01031         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01032 
01033         alignment = alignments[152]
01034         self.assertEqual(alignment.title[:50], "gi|68056232|ref|ZP_00540361.1| Twin-arginine trans")
01035         self.assertEqual(alignment.length, 68)
01036         self.assertEqual(len(alignment.hsps), 1)
01037         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01038 
01039         alignment = alignments[153]
01040         self.assertEqual(alignment.title[:50], "gi|68190120|gb|EAN04781.1| Twin-arginine transloca")
01041         self.assertEqual(alignment.length, 71)
01042         self.assertEqual(len(alignment.hsps), 1)
01043         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01044 
01045         alignment = alignments[154]
01046         self.assertEqual(alignment.title[:50], "gi|15605663|ref|NP_213038.1| hypothetical protein ")
01047         self.assertEqual(alignment.length, 77)
01048         self.assertEqual(len(alignment.hsps), 1)
01049         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01050 
01051         alignment = alignments[155]
01052         self.assertEqual(alignment.title[:50], "gi|60493413|emb|CAH08199.1| aerotolerance-related ")
01053         self.assertEqual(alignment.length, 238)
01054         self.assertEqual(len(alignment.hsps), 1)
01055         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01056 
01057         alignment = alignments[156]
01058         self.assertEqual(alignment.title[:50], "gi|50877510|emb|CAG37350.1| related to Sec-indepen")
01059         self.assertEqual(alignment.length, 84)
01060         self.assertEqual(len(alignment.hsps), 1)
01061         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01062 
01063         alignment = alignments[157]
01064         self.assertEqual(alignment.title[:50], "gi|42739647|gb|AAS43573.1| conserved domain protei")
01065         self.assertEqual(alignment.length, 236)
01066         self.assertEqual(len(alignment.hsps), 1)
01067         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01068 
01069         alignment = alignments[158]
01070         self.assertEqual(alignment.title[:50], "gi|53713708|ref|YP_099700.1| conserved hypothetica")
01071         self.assertEqual(alignment.length, 238)
01072         self.assertEqual(len(alignment.hsps), 1)
01073         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01074 
01075         alignment = alignments[159]
01076         self.assertEqual(alignment.title[:50], "gi|33860901|ref|NP_892462.1| mttA/Hcf106 family [P")
01077         self.assertEqual(alignment.length, 96)
01078         self.assertEqual(len(alignment.hsps), 1)
01079         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01080 
01081         alignment = alignments[160]
01082         self.assertEqual(alignment.title[:50], "gi|48851224|ref|ZP_00305466.1| COG1826: Sec-indepe")
01083         self.assertEqual(alignment.length, 83)
01084         self.assertEqual(len(alignment.hsps), 1)
01085         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01086 
01087         alignment = alignments[161]
01088         self.assertEqual(alignment.title[:50], "gi|67938449|ref|ZP_00530974.1| Twin-arginine trans")
01089         self.assertEqual(alignment.length, 69)
01090         self.assertEqual(len(alignment.hsps), 1)
01091         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01092 
01093         alignment = alignments[162]
01094         self.assertEqual(alignment.title[:50], "gi|45657833|ref|YP_001919.1| sec-independent prote")
01095         self.assertEqual(alignment.length, 90)
01096         self.assertEqual(len(alignment.hsps), 1)
01097         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01098 
01099         alignment = alignments[163]
01100         self.assertEqual(alignment.title[:50], "gi|57238048|ref|YP_179297.1| twin-arginine translo")
01101         self.assertEqual(alignment.length, 79)
01102         self.assertEqual(len(alignment.hsps), 1)
01103         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01104 
01105         alignment = alignments[164]
01106         self.assertEqual(alignment.title[:50], "gi|56962648|ref|YP_174374.1| sec-independent prote")
01107         self.assertEqual(alignment.length, 63)
01108         self.assertEqual(len(alignment.hsps), 1)
01109         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01110 
01111         alignment = alignments[165]
01112         self.assertEqual(alignment.title[:50], "gi|33239734|ref|NP_874676.1| Sec-independent prote")
01113         self.assertEqual(alignment.length, 84)
01114         self.assertEqual(len(alignment.hsps), 1)
01115         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01116 
01117         alignment = alignments[166]
01118         self.assertEqual(alignment.title[:50], "gi|21674434|ref|NP_662499.1| Sec-independent prote")
01119         self.assertEqual(alignment.length, 67)
01120         self.assertEqual(len(alignment.hsps), 1)
01121         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01122 
01123         alignment = alignments[167]
01124         self.assertEqual(alignment.title[:50], "gi|39968009|ref|XP_365395.1| hypothetical protein ")
01125         self.assertEqual(alignment.length, 823)
01126         self.assertEqual(len(alignment.hsps), 1)
01127         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01128 
01129         alignment = alignments[168]
01130         self.assertEqual(alignment.title[:50], "gi|4877986|gb|AAD31523.1| THA9 [Zea mays]")
01131         self.assertEqual(alignment.length, 169)
01132         self.assertEqual(len(alignment.hsps), 1)
01133         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01134 
01135         alignment = alignments[169]
01136         self.assertEqual(alignment.title[:50], "gi|67934419|ref|ZP_00527476.1| Twin-arginine trans")
01137         self.assertEqual(alignment.length, 56)
01138         self.assertEqual(len(alignment.hsps), 1)
01139         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01140 
01141         alignment = alignments[170]
01142         self.assertEqual(alignment.title[:50], "gi|42523658|ref|NP_969038.1| twin-argine protein t")
01143         self.assertEqual(alignment.length, 79)
01144         self.assertEqual(len(alignment.hsps), 1)
01145         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01146 
01147         alignment = alignments[171]
01148         self.assertEqual(alignment.title[:50], "gi|71546080|ref|ZP_00666945.1| Twin-arginine trans")
01149         self.assertEqual(alignment.length, 73)
01150         self.assertEqual(len(alignment.hsps), 1)
01151         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01152 
01153         alignment = alignments[172]
01154         self.assertEqual(alignment.title[:50], "gi|68002197|ref|ZP_00534828.1| Twin-arginine trans")
01155         self.assertEqual(alignment.length, 60)
01156         self.assertEqual(len(alignment.hsps), 1)
01157         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01158 
01159         alignment = alignments[173]
01160         self.assertEqual(alignment.title[:50], "gi|67481641|ref|XP_656170.1| hypothetical protein ")
01161         self.assertEqual(alignment.length, 434)
01162         self.assertEqual(len(alignment.hsps), 1)
01163         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01164 
01165         alignment = alignments[174]
01166         self.assertEqual(alignment.title[:50], "gi|50935447|ref|XP_477251.1| putative Calreticulin")
01167         self.assertEqual(alignment.length, 424)
01168         self.assertEqual(len(alignment.hsps), 1)
01169         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01170 
01171         alignment = alignments[175]
01172         self.assertEqual(alignment.title[:50], "gi|50978634|ref|NP_001003013.1| acidic (leucine-ri")
01173         self.assertEqual(alignment.length, 249)
01174         self.assertEqual(len(alignment.hsps), 1)
01175         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01176 
01177         alignment = alignments[176]
01178         self.assertEqual(alignment.title[:50], "gi|70936814|ref|XP_739300.1| 40S ribosomal subunit")
01179         self.assertEqual(alignment.length, 184)
01180         self.assertEqual(len(alignment.hsps), 1)
01181         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01182 
01183         alignment = alignments[177]
01184         self.assertEqual(alignment.title[:50], "gi|68075857|ref|XP_679848.1| hypothetical protein ")
01185         self.assertEqual(alignment.length, 340)
01186         self.assertEqual(len(alignment.hsps), 1)
01187         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01188 
01189         alignment = alignments[178]
01190         self.assertEqual(alignment.title[:50], "gi|39594005|emb|CAE70115.1| Hypothetical protein C")
01191         self.assertEqual(alignment.length, 192)
01192         self.assertEqual(len(alignment.hsps), 1)
01193         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01194 
01195         alignment = alignments[179]
01196         self.assertEqual(alignment.title[:50], "gi|66809957|ref|XP_638702.1| hypothetical protein ")
01197         self.assertEqual(alignment.length, 721)
01198         self.assertEqual(len(alignment.hsps), 1)
01199         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01200 
01201         alignment = alignments[180]
01202         self.assertEqual(alignment.title[:50], "gi|68550463|ref|ZP_00589911.1| Twin-arginine trans")
01203         self.assertEqual(alignment.length, 69)
01204         self.assertEqual(len(alignment.hsps), 1)
01205         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01206 
01207         alignment = alignments[181]
01208         self.assertEqual(alignment.title[:50], "gi|51473916|ref|YP_067673.1| TatA/E-like Sec-indep")
01209         self.assertEqual(alignment.length, 53)
01210         self.assertEqual(len(alignment.hsps), 1)
01211         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01212 
01213         alignment = alignments[182]
01214         self.assertEqual(alignment.title[:50], "gi|61857708|ref|XP_612559.1| PREDICTED: similar to")
01215         self.assertEqual(alignment.length, 236)
01216         self.assertEqual(len(alignment.hsps), 1)
01217         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01218 
01219         alignment = alignments[183]
01220         self.assertEqual(alignment.title[:50], "gi|39982651|gb|AAR34111.1| twin-arginine transloca")
01221         self.assertEqual(alignment.length, 59)
01222         self.assertEqual(len(alignment.hsps), 1)
01223         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01224 
01225         alignment = alignments[184]
01226         self.assertEqual(alignment.title[:50], "gi|50877509|emb|CAG37349.1| related to Sec-indepen")
01227         self.assertEqual(alignment.length, 66)
01228         self.assertEqual(len(alignment.hsps), 1)
01229         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01230 
01231         alignment = alignments[185]
01232         self.assertEqual(alignment.title[:50], "gi|52699323|ref|ZP_00340731.1| COG1826: Sec-indepe")
01233         self.assertEqual(alignment.length, 53)
01234         self.assertEqual(len(alignment.hsps), 1)
01235         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01236 
01237         alignment = alignments[186]
01238         self.assertEqual(alignment.title[:50], "gi|62426215|ref|ZP_00381343.1| COG1826: Sec-indepe")
01239         self.assertEqual(alignment.length, 93)
01240         self.assertEqual(len(alignment.hsps), 1)
01241         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01242 
01243         alignment = alignments[187]
01244         self.assertEqual(alignment.title[:50], "gi|11131838|sp|Q9SLY8|CRTC_ORYSA Calreticulin prec")
01245         self.assertEqual(alignment.length, 424)
01246         self.assertEqual(len(alignment.hsps), 1)
01247         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01248 
01249         alignment = alignments[188]
01250         self.assertEqual(alignment.title[:50], "gi|56543690|gb|AAV89844.1| Sec-independent protein")
01251         self.assertEqual(alignment.length, 87)
01252         self.assertEqual(len(alignment.hsps), 1)
01253         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01254 
01255         alignment = alignments[189]
01256         self.assertEqual(alignment.title[:50], "gi|67923730|ref|ZP_00517196.1| Twin-arginine trans")
01257         self.assertEqual(alignment.length, 95)
01258         self.assertEqual(len(alignment.hsps), 1)
01259         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01260 
01261         alignment = alignments[190]
01262         self.assertEqual(alignment.title[:50], "gi|67462585|ref|XP_647954.1| hypothetical protein ")
01263         self.assertEqual(alignment.length, 140)
01264         self.assertEqual(len(alignment.hsps), 1)
01265         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01266 
01267         alignment = alignments[191]
01268         self.assertEqual(alignment.title[:50], "gi|51970620|dbj|BAD44002.1| unknown protein [Arabi")
01269         self.assertEqual(alignment.length, 784)
01270         self.assertEqual(len(alignment.hsps), 1)
01271         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01272 
01273         alignment = alignments[192]
01274         self.assertEqual(alignment.title[:50], "gi|34581241|ref|ZP_00142721.1| hypothetical protei")
01275         self.assertEqual(alignment.length, 53)
01276         self.assertEqual(len(alignment.hsps), 1)
01277         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01278 
01279         alignment = alignments[193]
01280         self.assertEqual(alignment.title[:50], "gi|4877984|gb|AAD31522.1| THA4 [Zea mays]")
01281         self.assertEqual(alignment.length, 170)
01282         self.assertEqual(len(alignment.hsps), 1)
01283         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01284 
01285         alignment = alignments[194]
01286         self.assertEqual(alignment.title[:50], "gi|9757886|dbj|BAB08393.1| unnamed protein product")
01287         self.assertEqual(alignment.length, 707)
01288         self.assertEqual(len(alignment.hsps), 1)
01289         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01290 
01291         alignment = alignments[195]
01292         self.assertEqual(alignment.title[:50], "gi|32422107|ref|XP_331497.1| predicted protein [Ne")
01293         self.assertEqual(alignment.length, 216)
01294         self.assertEqual(len(alignment.hsps), 1)
01295         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01296 
01297         alignment = alignments[196]
01298         self.assertEqual(alignment.title[:50], "gi|68552035|ref|ZP_00591428.1| Twin-arginine trans")
01299         self.assertEqual(alignment.length, 70)
01300         self.assertEqual(len(alignment.hsps), 1)
01301         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01302 
01303         alignment = alignments[197]
01304         self.assertEqual(alignment.title[:50], "gi|68177649|ref|ZP_00550794.1| Twin-arginine trans")
01305         self.assertEqual(alignment.length, 58)
01306         self.assertEqual(len(alignment.hsps), 1)
01307         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01308 
01309         alignment = alignments[198]
01310         self.assertEqual(alignment.title[:50], "gi|67934756|ref|ZP_00527782.1| Twin-arginine trans")
01311         self.assertEqual(alignment.length, 65)
01312         self.assertEqual(len(alignment.hsps), 1)
01313         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01314 
01315         alignment = alignments[199]
01316         self.assertEqual(alignment.title[:50], "gi|42550455|gb|EAA73298.1| hypothetical protein FG")
01317         self.assertEqual(alignment.length, 297)
01318         self.assertEqual(len(alignment.hsps), 1)
01319         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01320 
01321         alignment = alignments[200]
01322         self.assertEqual(alignment.title[:50], "gi|15893083|ref|NP_360797.1| hypothetical protein ")
01323         self.assertEqual(alignment.length, 53)
01324         self.assertEqual(len(alignment.hsps), 1)
01325         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01326 
01327         alignment = alignments[201]
01328         self.assertEqual(alignment.title[:50], "gi|57233621|ref|YP_182297.1| twin-arginine translo")
01329         self.assertEqual(alignment.length, 65)
01330         self.assertEqual(len(alignment.hsps), 1)
01331         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01332 
01333         alignment = alignments[202]
01334         self.assertEqual(alignment.title[:50], "gi|75908036|ref|YP_322332.1| Twin-arginine translo")
01335         self.assertEqual(alignment.length, 56)
01336         self.assertEqual(len(alignment.hsps), 1)
01337         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01338 
01339         alignment = alignments[203]
01340         self.assertEqual(alignment.title[:50], "gi|72383453|ref|YP_292808.1| Twin-arginine translo")
01341         self.assertEqual(alignment.length, 71)
01342         self.assertEqual(len(alignment.hsps), 1)
01343         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01344 
01345         alignment = alignments[204]
01346         self.assertEqual(alignment.title[:50], "gi|1666185|emb|CAB04766.1| ORF13(1) [Rhodococcus e")
01347         self.assertEqual(alignment.length, 98)
01348         self.assertEqual(len(alignment.hsps), 1)
01349         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01350 
01351         alignment = alignments[205]
01352         self.assertEqual(alignment.title[:50], "gi|72138252|ref|XP_800288.1| PREDICTED: hypothetic")
01353         self.assertEqual(alignment.length, 946)
01354         self.assertEqual(len(alignment.hsps), 1)
01355         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01356 
01357         alignment = alignments[206]
01358         self.assertEqual(alignment.title[:50], "gi|67923190|ref|ZP_00516678.1| Twin-arginine trans")
01359         self.assertEqual(alignment.length, 50)
01360         self.assertEqual(len(alignment.hsps), 1)
01361         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01362 
01363         alignment = alignments[207]
01364         self.assertEqual(alignment.title[:50], "gi|3329623|gb|AAC26930.1| Hypothetical protein F36")
01365         self.assertEqual(alignment.length, 335)
01366         self.assertEqual(len(alignment.hsps), 1)
01367         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01368 
01369         alignment = alignments[208]
01370         self.assertEqual(alignment.title[:50], "gi|39597929|emb|CAE68621.1| Hypothetical protein C")
01371         self.assertEqual(alignment.length, 2691)
01372         self.assertEqual(len(alignment.hsps), 1)
01373         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01374 
01375         alignment = alignments[209]
01376         self.assertEqual(alignment.title[:50], "gi|68182025|ref|ZP_00555006.1| hypothetical protei")
01377         self.assertEqual(alignment.length, 438)
01378         self.assertEqual(len(alignment.hsps), 1)
01379         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01380 
01381         alignment = alignments[210]
01382         self.assertEqual(alignment.title[:50], "gi|21204492|dbj|BAB95189.1| ebh [Staphylococcus au")
01383         self.assertEqual(alignment.length, 9904)
01384         self.assertEqual(len(alignment.hsps), 1)
01385         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01386 
01387         alignment = alignments[211]
01388         self.assertEqual(alignment.title[:50], "gi|39593039|emb|CAE64508.1| Hypothetical protein C")
01389         self.assertEqual(alignment.length, 960)
01390         self.assertEqual(len(alignment.hsps), 1)
01391         self.assertTrue(alignment.hsps[0].expect > E_VALUE_THRESH)
01392 
01393         self.assertRaises(StopIteration, records.next)
01394         handle.close()
01395 
01396         handle = open(datafile)
01397         record = NCBIXML.read(handle)
01398         handle.close()

Here is the call graph for this function:

Definition at line 1399 of file test_NCBIXML.py.

01399 
01400     def test_xbt002(self):
01401         "Parsing BLASTN 2.2.12, gi|1348916|gb|G26684.1|G26684 (xbt002)"
01402 
01403         filename = 'xbt002.xml'
01404         datafile = os.path.join("Blast", filename)
01405         handle = open(datafile)
01406         records = NCBIXML.parse(handle)
01407         record = records.next()
01408         alignments = record.alignments
01409 
01410         self.assertEqual(record.query_id, "gi|1348916|gb|G26684.1|G26684")
01411         self.assertEqual(len(alignments), 2)
01412         self.assertEqual(sum([len(a.hsps) for a in alignments]), 2)
01413         self.assertEqual(alignments[0].title[:50], "gi|9950606|gb|AE004854.1| Pseudomonas aeruginosa P")
01414         self.assertEqual(alignments[0].length, 11884)
01415         self.assertEqual(len(alignments[0].hsps), 1)
01416         self.assertTrue(alignments[0].hsps[0].expect > E_VALUE_THRESH)
01417         self.assertEqual(alignments[1].title[:50], "gi|15073988|emb|AL591786.1|SME591786 Sinorhizobium")
01418         self.assertEqual(alignments[1].length, 299350)
01419         self.assertEqual(len(alignments[1].hsps), 1)
01420         self.assertTrue(alignments[1].hsps[0].expect > E_VALUE_THRESH)
01421 
01422         self.assertRaises(StopIteration, records.next)
01423         handle.close()
01424 
01425         handle = open(datafile)
01426         record = NCBIXML.read(handle)
01427         handle.close()

Here is the call graph for this function:

Definition at line 1428 of file test_NCBIXML.py.

01428 
01429     def test_xbt003(self):
01430         "Parsing BLASTX 2.2.12, gi|1347369|gb|G25137.1|G25137 (xbt003)"
01431 
01432         filename = 'xbt003.xml'
01433         datafile = os.path.join("Blast", filename)
01434 
01435         handle = open(datafile)
01436         records = NCBIXML.parse(handle)
01437         record = records.next()
01438         alignments = record.alignments
01439         self.assertEqual(record.query_id, "gi|1347369|gb|G25137.1|G25137")
01440         self.assertEqual(len(alignments), 78)
01441         self.assertEqual(sum([len(a.hsps) for a in alignments]), 84)
01442         self.assertRaises(StopIteration, records.next)
01443         handle.close()
01444 
01445         handle = open(datafile)
01446         record = NCBIXML.read(handle)
01447         handle.close()

Here is the call graph for this function:

Definition at line 1448 of file test_NCBIXML.py.

01448 
01449     def test_xbt004(self):
01450         "Parsing TBLASTN 2.2.12, gi|729325|sp|P39483|DHG2_BACME (xbt004)"
01451 
01452         filename = 'xbt004.xml'
01453         datafile = os.path.join("Blast", filename)
01454 
01455         handle = open(datafile)
01456         records = NCBIXML.parse(handle)
01457         record = records.next()
01458         alignments = record.alignments
01459         self.assertEqual(record.query_id, "gi|729325|sp|P39483|DHG2_BACME")
01460         self.assertEqual(len(alignments), 100)
01461         self.assertEqual(sum([len(a.hsps) for a in alignments]), 127)
01462         self.assertRaises(StopIteration, records.next)
01463         handle.close()
01464 
01465         handle = open(datafile)
01466         record = NCBIXML.read(handle)
01467         handle.close()

Here is the call graph for this function:

Definition at line 1468 of file test_NCBIXML.py.

01468 
01469     def test_xbt005(self):
01470         "Parsing TBLASTX 2.2.12, gi|1348853|gb|G26621.1|G26621, BLOSUM80 (xbt005)"
01471 
01472         filename = 'xbt005.xml'
01473         datafile = os.path.join("Blast", filename)
01474 
01475         handle = open(datafile)
01476         records = NCBIXML.parse(handle)
01477         record = records.next()
01478         alignments = record.alignments
01479         self.assertEqual(record.query_id, "gi|1348853|gb|G26621.1|G26621")
01480         self.assertEqual(len(alignments), 10)
01481         self.assertEqual(sum([len(a.hsps) for a in alignments]), 102)
01482         self.assertRaises(StopIteration, records.next)
01483         handle.close()
01484 
01485         handle = open(datafile)
01486         record = NCBIXML.read(handle)
01487         handle.close()

Here is the call graph for this function:

Definition at line 1488 of file test_NCBIXML.py.

01488 
01489     def test_xbt006(self):
01490         "Parsing BLASTP 2.2.18+, gi|160837788|ref|NP_075631.2| (xbt006)"
01491         # NOTE - no date in version field, downloaded 2008/05/08
01492 
01493         filename = 'xbt006.xml'
01494         datafile = os.path.join("Blast", filename)
01495 
01496         handle = open(datafile)
01497         records = NCBIXML.parse(handle)
01498 
01499         record = records.next()
01500         alignments = record.alignments
01501         self.assertEqual(record.query_id, "31493")
01502         self.assertEqual(len(alignments), 10)
01503         self.assertEqual(sum([len(a.hsps) for a in alignments]), 14)
01504         self.assertEqual(alignments[0].title[:50], "gi|151942244|gb|EDN60600.1| cytosolic iron-sulfur ")
01505         self.assertEqual(alignments[0].length, 330)
01506         self.assertEqual(len(alignments[0].hsps), 1)
01507         self.assertTrue(alignments[0].hsps[0].expect > E_VALUE_THRESH)
01508         self.assertEqual(alignments[1].title[:50], "gi|476059|emb|CAA55606.1| YBR0832 [Saccharomyces c")
01509         self.assertEqual(alignments[1].length, 535)
01510         self.assertEqual(len(alignments[1].hsps), 1)
01511         self.assertTrue(alignments[1].hsps[0].expect > E_VALUE_THRESH)
01512         self.assertEqual(alignments[2].title[:50], "gi|6320473|ref|NP_010553.1| Essential protein invo")
01513         self.assertEqual(alignments[2].length, 330)
01514         self.assertEqual(len(alignments[2].hsps), 1)
01515         self.assertTrue(alignments[2].hsps[0].expect > E_VALUE_THRESH)
01516         self.assertEqual(alignments[3].title[:50], "gi|61679798|pdb|1R5M|A Chain A, Crystal Structure ")
01517         self.assertEqual(alignments[3].length, 425)
01518         self.assertEqual(len(alignments[3].hsps), 1)
01519         self.assertTrue(alignments[3].hsps[0].expect > E_VALUE_THRESH)
01520         self.assertEqual(alignments[4].title[:50], "gi|6319579|ref|NP_009661.1| WD40 repeat-containing")
01521         self.assertEqual(alignments[4].length, 535)
01522         self.assertEqual(len(alignments[4].hsps), 1)
01523         self.assertTrue(alignments[4].hsps[0].expect > E_VALUE_THRESH)
01524         self.assertEqual(alignments[5].title[:50], "gi|151946495|gb|EDN64717.1| Sir4p-interacting fact")
01525         self.assertEqual(alignments[5].length, 535)
01526         self.assertEqual(len(alignments[5].hsps), 1)
01527         self.assertTrue(alignments[5].hsps[0].expect > E_VALUE_THRESH)
01528         self.assertEqual(alignments[6].title[:50], "gi|151943708|gb|EDN62018.1| nuclear pore complex s")
01529         self.assertEqual(alignments[6].length, 349)
01530         self.assertEqual(len(alignments[6].hsps), 2)
01531         self.assertTrue(alignments[6].hsps[0].expect > E_VALUE_THRESH)
01532         self.assertTrue(alignments[6].hsps[1].expect > E_VALUE_THRESH)
01533         self.assertEqual(alignments[7].title[:50], "gi|151567866|pdb|2PM7|B Chain B, Crystal Structure")
01534         self.assertEqual(alignments[7].length, 297)
01535         self.assertEqual(len(alignments[7].hsps), 2)
01536         self.assertTrue(alignments[7].hsps[0].expect > E_VALUE_THRESH)
01537         self.assertTrue(alignments[7].hsps[1].expect > E_VALUE_THRESH)
01538         self.assertEqual(alignments[8].title[:50], "gi|6321338|ref|NP_011415.1| Nuclear pore protein t")
01539         self.assertEqual(alignments[8].length, 349)
01540         self.assertEqual(len(alignments[8].hsps), 2)
01541         self.assertTrue(alignments[8].hsps[0].expect > E_VALUE_THRESH)
01542         self.assertTrue(alignments[8].hsps[1].expect > E_VALUE_THRESH)
01543         self.assertEqual(alignments[9].title[:50], "gi|151567870|pdb|2PM9|B Chain B, Crystal Structure")
01544         self.assertEqual(alignments[9].length, 297)
01545         self.assertEqual(len(alignments[9].hsps), 2)
01546         self.assertTrue(alignments[9].hsps[0].expect > E_VALUE_THRESH)
01547         self.assertTrue(alignments[9].hsps[1].expect > E_VALUE_THRESH)
01548 
01549         self.assertRaises(StopIteration, records.next)
01550         handle.close()
01551 
01552         handle = open(datafile)
01553         record = NCBIXML.read(handle)
01554         handle.close()

Here is the call graph for this function:

Definition at line 1555 of file test_NCBIXML.py.

01555 
01556     def test_xbt007(self):
01557         "Parsing BLASTP 2.2.18+, SwissProt Q08386 and P07175, no hits (xbt007)"
01558 
01559         filename = 'xbt007.xml'
01560         datafile = os.path.join("Blast", filename)
01561         handle = open(datafile)
01562         records = NCBIXML.parse(handle)
01563         record = records.next()
01564         self.assertEqual(record.query_id, "gi|585505|sp|Q08386|MOPB_RHOCA")
01565         alignments = record.alignments
01566         self.assertEqual(len(record.alignments), 0)
01567         record = records.next()
01568         self.assertEqual(record.query_id, "gi|129628|sp|P07175.1|PARA_AGRTU")
01569         self.assertEqual(len(record.alignments), 0)
01570         self.assertRaises(StopIteration, records.next)
01571         handle.close()

Here is the call graph for this function:

Definition at line 1572 of file test_NCBIXML.py.

01572 
01573     def test_xbt008(self):
01574         "Parsing BLASTP 2.2.18, Fake query (xbt008)"
01575 
01576         filename = 'xbt008.xml'
01577         datafile = os.path.join("Blast", filename)
01578 
01579         handle = open(datafile)
01580         records = NCBIXML.parse(handle)
01581         record = records.next()
01582         self.assertEqual(record.query_id, "lcl|1_0")
01583         alignments = record.alignments
01584         self.assertEqual(len(alignments), 0)
01585         self.assertRaises(StopIteration, records.next)
01586         handle.close()
01587 
01588         handle = open(datafile)
01589         record = NCBIXML.read(handle)
01590         handle.close()

Here is the call graph for this function:

Definition at line 1591 of file test_NCBIXML.py.

01591 
01592     def test_xbt009(self):
01593         "Parsing BLASTX 2.2.22+, multiple queries against NR (xbt009)"
01594         #See also plain text file bt081.txt (matching output from blastx tool)
01595 
01596         filename = 'xbt009.xml'
01597         datafile = os.path.join("Blast", filename)
01598 
01599         handle = open(datafile)
01600         records = NCBIXML.parse(handle)
01601 
01602         record = records.next()
01603         self.assertEqual(record.application, "BLASTX")
01604         self.assertEqual(record.version, '2.2.22+')
01605         self.assertEqual(record.date, "")
01606         self.assertEqual(record.query, "gi|4104054|gb|AH007193.1|SEG_CVIGS Centaurea vallesiaca 18S ribosomal RNA gene, partial sequence")
01607         self.assertEqual(record.query_letters, 1002)
01608         self.assertEqual(record.database, "nr")
01609         self.assertEqual(record.num_sequences_in_database, 8994603)
01610         self.assertEqual(record.database_sequences, 8994603)
01611         #self.assertEqual(record.database_length, 3078807967)
01612         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01613         self.assertEqual(len(record.descriptions), 1)
01614         self.assertEqual(len(record.alignments), 1)
01615         self.assertEqual(len(record.alignments[0].hsps), 1)
01616 
01617         record = records.next()
01618         self.assertEqual(record.application, "BLASTX")
01619         self.assertEqual(record.version, '2.2.22+')
01620         self.assertEqual(record.date, "")
01621         self.assertEqual(record.query, "gi|4218935|gb|AF074388.1|AF074388 Sambucus nigra hevein-like protein HLPf gene, partial cds")
01622         self.assertEqual(record.query_letters, 2050)
01623         self.assertEqual(record.database, "nr")
01624         self.assertEqual(record.num_sequences_in_database, 8994603)
01625         self.assertEqual(record.database_sequences, 8994603)
01626         #self.assertEqual(record.database_length, 3078807967)
01627         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01628         # I used -num_descriptions 10 and -num_alignments 1
01629         self.assertEqual(len(record.descriptions), 10)
01630         self.assertEqual(len(record.alignments), 10)
01631         self.assertEqual(len(record.alignments[0].hsps), 2)
01632         self.assertEqual(len(record.alignments[1].hsps), 2)
01633         self.assertEqual(len(record.alignments[9].hsps), 2)
01634         
01635         record = records.next()
01636         self.assertEqual(record.application, "BLASTX")
01637         self.assertEqual(record.version, '2.2.22+')
01638         self.assertEqual(record.date, "")
01639         self.assertEqual(record.query, "gi|5690369|gb|AF158246.1|AF158246 Cricetulus griseus glucose phosphate isomerase (GPI) gene, partial intron sequence")
01640         self.assertEqual(record.query_letters, 550)
01641         self.assertEqual(record.database, "nr")
01642         self.assertEqual(record.num_sequences_in_database, 8994603)
01643         self.assertEqual(record.database_sequences, 8994603)
01644         #self.assertEqual(record.database_length, 3078807967)
01645         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01646         self.assertEqual(len(record.descriptions), 0)
01647         self.assertEqual(len(record.alignments), 0)
01648 
01649         record = records.next()
01650         self.assertEqual(record.application, "BLASTX")
01651         self.assertEqual(record.version, '2.2.22+')
01652         self.assertEqual(record.date, "")
01653         self.assertEqual(record.query, "gi|5049839|gb|AI730987.1|AI730987 BNLGHi8354 Six-day Cotton fiber Gossypium hirsutum cDNA 5' similar to TUBULIN BETA-1 CHAIN gi|486734|pir|S35142 tubulin beta chain - white lupine gi|402636 (X70184) Beta tubulin 1 [Lupinus albus], mRNA sequence")
01654         self.assertEqual(record.query_letters, 655)
01655         self.assertEqual(record.database, "nr")
01656         self.assertEqual(record.num_sequences_in_database, 8994603)
01657         self.assertEqual(record.database_sequences, 8994603)
01658         #self.assertEqual(record.database_length, 3078807967)
01659         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01660         self.assertEqual(len(record.descriptions), 10)
01661         self.assertEqual(len(record.alignments), 10)
01662         self.assertEqual(len(record.alignments[0].hsps), 1)
01663         self.assertEqual(len(record.alignments[9].hsps), 1)
01664 
01665         record = records.next()
01666         self.assertEqual(record.application, "BLASTX")
01667         self.assertEqual(record.version, '2.2.22+')
01668         self.assertEqual(record.date, "")
01669         self.assertEqual(record.query, "gi|5052071|gb|AF067555.1|AF067555 Phlox stansburyi internal transcribed spacer 1, 5.8S ribosomal RNA gene, and internal transcribed spacer 2, complete sequence")
01670         self.assertEqual(record.query_letters, 623)
01671         self.assertEqual(record.database, "nr")
01672         self.assertEqual(record.num_sequences_in_database, 8994603)
01673         self.assertEqual(record.database_sequences, 8994603)
01674         #self.assertEqual(record.database_length, 3078807967)
01675         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01676         self.assertEqual(len(record.descriptions), 10)
01677         self.assertEqual(len(record.alignments), 10)
01678         self.assertEqual(len(record.alignments[0].hsps), 2)
01679         self.assertEqual(len(record.alignments[9].hsps), 1)
01680 
01681         record = records.next()
01682         self.assertEqual(record.application, "BLASTX")
01683         self.assertEqual(record.version, '2.2.22+')
01684         self.assertEqual(record.date, "")
01685         self.assertEqual(record.query, "gi|3176602|gb|U78617.1|LOU78617 Lathyrus odoratus phytochrome A (PHYA) gene, partial cds")
01686         self.assertEqual(record.query_letters, 309)
01687         self.assertEqual(record.database, "nr")
01688         self.assertEqual(record.num_sequences_in_database, 8994603)
01689         self.assertEqual(record.database_sequences, 8994603)
01690         #self.assertEqual(record.database_length, 3078807967)
01691         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01692         self.assertEqual(len(record.descriptions), 10)
01693         self.assertEqual(len(record.alignments), 10)
01694         self.assertEqual(len(record.alignments[0].hsps), 1)
01695         self.assertEqual(len(record.alignments[9].hsps), 1)
01696 
01697         record = records.next()
01698         self.assertEqual(record.application, "BLASTX")
01699         self.assertEqual(record.version, '2.2.22+')
01700         self.assertEqual(record.date, "")
01701         self.assertEqual(record.query, "gi|5817701|gb|AF142731.1|AF142731 Wisteria frutescens maturase-like protein (matK) gene, complete cds; chloroplast gene for chloroplast product")
01702         self.assertEqual(record.query_letters, 2551)
01703         self.assertEqual(record.database, "nr")
01704         self.assertEqual(record.num_sequences_in_database, 8994603)
01705         self.assertEqual(record.database_sequences, 8994603)
01706         #self.assertEqual(record.database_length, 3078807967)
01707         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01708         self.assertEqual(len(record.descriptions), 10)
01709         self.assertEqual(len(record.alignments), 10)
01710         self.assertEqual(len(record.alignments[0].hsps), 1)
01711         self.assertEqual(len(record.alignments[9].hsps), 1)
01712 
01713         self.assertRaises(StopIteration, records.next)
01714         handle.close()

Here is the call graph for this function:

Definition at line 1715 of file test_NCBIXML.py.

01715 
01716     def test_xbt010(self):
01717         "Parsing BLASTP 2.2.22+, multiple queries against NR (xbt010)"
01718         #This is from blastp NOT blastall
01719 
01720         filename = 'xbt010.xml'
01721         datafile = os.path.join("Blast", filename)
01722 
01723         handle = open(datafile)
01724         records = NCBIXML.parse(handle)
01725 
01726         record = records.next()
01727         self.assertEqual(record.application, "BLASTP")
01728         self.assertEqual(record.version, '2.2.22+')
01729         self.assertEqual(record.date, "")
01730         self.assertEqual(record.query, "gi|3298468|dbj|BAA31520.1| SAMIPF")
01731         self.assertEqual(record.query_letters, 107)
01732         self.assertEqual(record.database, "nr")
01733         self.assertEqual(record.num_sequences_in_database, 8994603)
01734         self.assertEqual(record.database_sequences, 8994603)
01735         #self.assertEqual(record.database_length, 3078807967)
01736         self.assertEqual(record.database_length, -1216159329) #NCBI bug!
01737         self.assertEqual(len(record.descriptions), 10)
01738         self.assertEqual(len(record.alignments), 10)
01739         self.assertEqual(len(record.alignments[0].hsps), 1)
01740 
01741         record = records.next()
01742         self.assertEqual(record.query, "gi|2781234|pdb|1JLY|B Chain B, Crystal Structure Of Amaranthus Caudatus Agglutinin")
01743         self.assertEqual(record.query_letters, 304)
01744 
01745         record = records.next()
01746         self.assertEqual(record.query, "gi|4959044|gb|AAD34209.1|AF069992_1 LIM domain interacting RING finger protein")
01747         self.assertEqual(record.query_letters, 600)
01748 
01749         record = records.next()
01750         self.assertEqual(record.query, "gi|671626|emb|CAA85685.1| rubisco large subunit")
01751         self.assertEqual(record.query_letters, 473)
01752 
01753         self.assertRaises(StopIteration, records.next)
01754         handle.close()

Here is the call graph for this function:

Definition at line 1755 of file test_NCBIXML.py.

01755 
01756     def test_xbt011(self):
01757         "Parsing PSI-BLASTP 2.2.18, single query which converges in 3 iterations (xbt011)"
01758         #This is from old pgpblast command line tool, NOT new psiblast
01759         #NOTE - The parser currently returns three BLAST record objects.
01760         #The old text parser would return a single PSI BLAST record object with three rounds.
01761         #This may change... although it may require a PSI BLAST specific XML parser.
01762 
01763         filename = 'xbt011.xml'
01764         datafile = os.path.join("Blast", filename)
01765 
01766         handle = open(datafile)
01767         records = NCBIXML.parse(handle)
01768 
01769         record = records.next()
01770         self.assertEqual(record.application, "BLASTP")
01771         self.assertEqual(record.version, '2.2.18')
01772         self.assertEqual(record.date, "Mar-02-2008")
01773         self.assertEqual(record.query, "tr|Q3V4Q3|Q3V4Q3_9VIRU")
01774         self.assertEqual(record.query_letters, 131)
01775         self.assertEqual(record.database, "/opt/BlastDBs/nr")
01776         self.assertEqual(record.num_sequences_in_database, 2563094)
01777         self.assertEqual(record.database_sequences, 2563094)
01778         self.assertEqual(record.database_length, 864488805)
01779         self.assertEqual(len(record.descriptions), 11)
01780         self.assertEqual(len(record.alignments), 11)
01781         self.assertEqual(len(record.alignments[0].hsps), 1)
01782         hsp = record.alignments[0].hsps[0]
01783         self.assertEqual(hsp.align_length, 131)
01784         self.assertEqual(hsp.identities, 131)
01785         self.assertEqual(hsp.positives, 131)
01786         self.assertEqual(hsp.query, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01787         self.assertEqual(hsp.sbjct, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01788         self.assertEqual(hsp.match, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01789         self.assertEqual(hsp.score, 680)
01790         self.assertEqual(hsp.expect, 4.72196e-70)
01791         self.assertEqual(hsp.query_start, 1)
01792         self.assertEqual(hsp.query_end, 131)
01793         self.assertEqual(hsp.sbjct_start, 1)
01794         self.assertEqual(hsp.sbjct_end, 131)
01795         self.assertEqual(len(record.alignments[1].hsps), 1)
01796         hsp = record.alignments[1].hsps[0]
01797         self.assertEqual(hsp.align_length, 77)
01798         self.assertEqual(hsp.identities, 36)
01799         self.assertEqual(hsp.positives, 49)
01800         self.assertEqual(hsp.query, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQ")
01801         self.assertEqual(hsp.sbjct, "MAREEPYKGDYVGGVAKILQGYFANYYGFPNVSLRLAGEEANLSKTGHANAKAIVHEMIKVIKEASKPLR-RGKGFK")
01802         self.assertEqual(hsp.match, "MA+ EP KGDY GG  KIL  +     G+P V+L+LAGEEAN  + G    K  +H ++K+I +A KP R +G GF+")
01803         self.assertEqual(hsp.score, 181)
01804         self.assertEqual(hsp.expect, 3.03476e-12)
01805         self.assertEqual(hsp.query_start, 1)
01806         self.assertEqual(hsp.query_end, 77)
01807         self.assertEqual(hsp.sbjct_start, 1)
01808         self.assertEqual(hsp.sbjct_end, 76)
01809 
01810         record = records.next()
01811         self.assertEqual(record.application, "BLASTP")
01812         self.assertEqual(record.version, '2.2.18')
01813         self.assertEqual(record.date, "Mar-02-2008")
01814         self.assertEqual(record.query, "tr|Q3V4Q3|Q3V4Q3_9VIRU")
01815         self.assertEqual(record.query_letters, 131)
01816         self.assertEqual(record.database, "/opt/BlastDBs/nr")
01817         self.assertEqual(record.num_sequences_in_database, 2563094)
01818         self.assertEqual(record.database_sequences, 2563094)
01819         self.assertEqual(record.database_length, 864488805)
01820         self.assertEqual(len(record.descriptions), 19)
01821         self.assertEqual(len(record.alignments), 19)
01822         self.assertEqual(len(record.alignments[0].hsps), 1)
01823         hsp = record.alignments[0].hsps[0]
01824         self.assertEqual(hsp.align_length, 131)
01825         self.assertEqual(hsp.identities, 131)
01826         self.assertEqual(hsp.positives, 131)
01827         self.assertEqual(hsp.query, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01828         self.assertEqual(hsp.sbjct, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01829         self.assertEqual(hsp.match, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01830         self.assertEqual(hsp.score, 590)
01831         self.assertEqual(hsp.expect, 1.28615e-59)
01832         self.assertEqual(hsp.query_start, 1)
01833         self.assertEqual(hsp.query_end, 131)
01834         self.assertEqual(hsp.sbjct_start, 1)
01835         self.assertEqual(hsp.sbjct_end, 131)
01836 
01837         record = records.next()
01838         self.assertEqual(record.application, "BLASTP")
01839         self.assertEqual(record.version, '2.2.18')
01840         self.assertEqual(record.date, "Mar-02-2008")
01841         self.assertEqual(record.query, "tr|Q3V4Q3|Q3V4Q3_9VIRU")
01842         self.assertEqual(record.query_letters, 131)
01843         self.assertEqual(record.database, "/opt/BlastDBs/nr")
01844         self.assertEqual(record.num_sequences_in_database, 2563094)
01845         self.assertEqual(record.database_sequences, 2563094)
01846         self.assertEqual(record.database_length, 864488805)
01847         self.assertEqual(len(record.descriptions), 9)
01848         self.assertEqual(len(record.alignments), 9)
01849         self.assertEqual(len(record.alignments[0].hsps), 1)
01850         hsp = record.alignments[0].hsps[0]
01851         self.assertEqual(hsp.align_length, 131)
01852         self.assertEqual(hsp.identities, 131)
01853         self.assertEqual(hsp.positives, 131)
01854         self.assertEqual(hsp.query, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01855         self.assertEqual(hsp.sbjct, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01856         self.assertEqual(hsp.match, "MAKYEPKKGDYAGGAVKILDMFENGQLGYPEVTLKLAGEEANARRAGDERTKEAIHAIVKMISDAMKPYRNKGSGFQSQPIPGEVIAQVTSNPEYQQAKAFLASPATQVRNIEREEVLSKGAKKLAQAMAS")
01857         self.assertEqual(hsp.score, 535)
01858         self.assertEqual(hsp.expect, 3.43623e-53)
01859         self.assertEqual(hsp.query_start, 1)
01860         self.assertEqual(hsp.query_end, 131)
01861         self.assertEqual(hsp.sbjct_start, 1)
01862         self.assertEqual(hsp.sbjct_end, 131)
01863 
01864         #TODO - Can we detect the convergence status:
01865         #<Iteration_message>CONVERGED</Iteration_message>
01866         self.assertRaises(StopIteration, records.next)
01867         handle.close()
01868 

Here is the call graph for this function:


The documentation for this class was generated from the following file: