Package Bio :: Module StdHandler
[hide private]
[frames] | no frames]

Source Code for Module Bio.StdHandler

  1  # Standard Content and Dispatch handlers for the Bioformat IO system 
  2  # This is a Python module. 
  3  """This module is DEPRECATED. 
  4   
  5  Andrew Dalke is no longer maintaining Martel or Bio.Mindy, and these modules 
  6  and associate ones like Bio.StdHandler are now deprecated.  They are no longer 
  7  used in any of the current Biopython parsers, and are likely to be removed 
  8  in a future release. 
  9  """ 
 10   
 11  import warnings 
 12  warnings.warn("Martel and those parts of Biopython depending on it" \ 
 13                +" directly (such as Bio.Mindy and Bio.StdHandler) are now" \ 
 14                +" deprecated, and will be removed in a future release of"\ 
 15                +" Biopython.  If you want to continue to use this code,"\ 
 16                +" please get in contact with the Biopython developers via"\ 
 17                +" the mailing lists to avoid its permanent removal from"\ 
 18                +" Biopython.", \ 
 19                DeprecationWarning) 
 20   
 21  from xml.sax import handler 
 22  from Martel import Parser, Dispatch 
 23  from Bio import Std, Decode 
 24   
 25  ################################### 
 26   
 27  # Helper functions to make functions 
 28   
29 -def add_int_handler(klass, tag, attrname):
30 assert not hasattr(klass, "start_" +tag), "existing method exists" 31 assert not hasattr(klass, "end_" +tag), "existing method exists" 32 s = """if 1: 33 def start(self, tag, attrs): 34 self.save_characters() 35 def end(self, tag): 36 self.%s = int(self.get_characters()) 37 """ % attrname 38 d = {} 39 exec s in d 40 setattr(klass, "start_" + tag, d["start"]) 41 setattr(klass, "end_" + tag, d["end"])
42
43 -def add_text_handler(klass, tag, attrname):
44 assert not hasattr(klass, "start_" +tag), "existing method exists" 45 assert not hasattr(klass, "end_" +tag), "existing method exists" 46 s = """if 1: 47 def start(self, tag, attrs): 48 self.save_characters() 49 def end(self, tag): 50 self.%s = self.get_characters() 51 """ % attrname 52 d = {} 53 exec s in d 54 setattr(klass, "start_" + tag, d["start"]) 55 setattr(klass, "end_" + tag, d["end"])
56
57 -def add_text_dict_handler(klass, tag, attrname, key):
58 assert not hasattr(klass, "start_" +tag), "existing method exists" 59 assert not hasattr(klass, "end_" +tag), "existing method exists" 60 s = """if 1: 61 def start(self, tag, attrs): 62 self.save_characters() 63 def end(self, tag): 64 self.%s["%s"] = self.get_characters() 65 """ % (attrname, key) 66 d = {} 67 exec s in d 68 setattr(klass, "start_" + tag, d["start"]) 69 setattr(klass, "end_" + tag, d["end"])
70
71 -def add_text_decode_handler(klass, tag, attrname):
72 assert not hasattr(klass, "start_" +tag), "existing method exists" 73 assert not hasattr(klass, "end_" +tag), "existing method exists" 74 s = """if 1: 75 def start(self, tag, attrs): 76 self.save_characters() 77 self._decode_%s = attrs.get("bioformat:decode", None) 78 def end(self, tag): 79 if self._decode_%s is not None: 80 s = Decode.make_decoder(self._decode_%s)(s) 81 self.%s = self.get_characters() 82 """ % (tag, tag, tag, attrname) 83 d = {"Decode": Decode} 84 exec s in d 85 setattr(klass, "start_" + tag, d["start"]) 86 setattr(klass, "end_" + tag, d["end"])
87
88 -def add_first_text_handler(klass, tag, attrname):
89 assert not hasattr(klass, "start_" +tag), "existing method exists" 90 assert not hasattr(klass, "end_" +tag), "existing method exists" 91 s = """if 1: 92 def start(self, tag, attrs): 93 if self.%s is None: 94 self.save_characters() 95 def end(self, tag): 96 if self.%s is None: 97 self.%s = self.get_characters() 98 """ % (attrname, attrname, attrname) 99 d = {} 100 exec s in d 101 setattr(klass, "start_" + tag, d["start"]) 102 setattr(klass, "end_" + tag, d["end"])
103
104 -def add_text_block_handler(klass, tag, joinattr, defaultjoin, attrname):
105 assert not hasattr(klass, "start_" + tag), "existing method exists" 106 assert not hasattr(klass, "end_" + tag), "existing method exists" 107 assert not hasattr(klass, "start_"+tag+"_block"), "existing method exists" 108 assert not hasattr(klass, "end_" +tag+"_block"), "existing method exists" 109 s = """if 1: 110 def start_block(self, tag, attrs): 111 self._%(tag)s_join_func = Decode.make_decoder(attrs.get(%(joinattr)r, %(defaultjoin)r)) 112 self._%(tag)s_lines = [] 113 def end_block(self, tag): 114 self.%(attrname)s = self._%(tag)s_join_func(self._%(tag)s_lines) 115 def start(self, tag, attrs): 116 self.save_characters() 117 def end(self, tag): 118 self._%(tag)s_lines.append(self.get_characters()) 119 """ % locals() 120 d = {"Decode": Decode} 121 exec s in d 122 setattr(klass, "start_" + tag, d["start"]) 123 setattr(klass, "end_" + tag, d["end"]) 124 setattr(klass, "start_" + tag + "_block", d["start_block"]) 125 setattr(klass, "end_" + tag + "_block", d["end_block"])
126
127 -def add_value_handler(klass, tag, attrname):
128 assert not hasattr(klass, "start_" +tag), "existing method exists" 129 assert not hasattr(klass, "end_" +tag), "existing method exists" 130 s = """if 1: 131 def start(self, tag, attrs): 132 self._%(tag)s_name = attrs["name"] 133 self._%(tag)s_decode = attrs.get("bioformat:decode", None) 134 self.save_characters() 135 def end(self, tag): 136 s = self.get_characters() 137 if self._%(tag)s_decode is not None: 138 s = Decode.make_decoder(self._%(tag)s_decode)(s) 139 self.%(attrname)s[self._%(tag)s_name] = s 140 """ % locals() 141 d = {"Decode": Decode} 142 exec s in d 143 setattr(klass, "start_" + tag, d["start"]) 144 setattr(klass, "end_" + tag, d["end"])
145 146 147 ################################# 148
149 -class ConvertHandler(handler.ContentHandler):
150 """Used to read records and produce output"""
151 - def __init__(self, record_builder, writer, record_tag = "record"):
152 handler.ContentHandler.__init__(self) 153 self.record_builder = record_builder 154 self.writer = writer 155 self.record_tag = record_tag
156
157 - def startDocument(self):
158 self.inside_record = 0 159 self.characters = self.ignore_characters
160
161 - def startElement(self, tag, attrs):
162 if self.inside_record: 163 self.record_builder.startElement(tag, attrs) 164 elif tag == self.record_tag: 165 self.record_builder.startDocument() 166 self.inside_record = 1 167 self.characters = self.record_builder.characters 168 self.record_builder.startElement(tag, attrs)
169
170 - def endElement(self, tag):
171 if self.inside_record: 172 self.record_builder.endElement(tag) 173 if tag == self.record_tag: 174 self.record_builder.endDocument() 175 self.writer.write(self.record_builder.document) 176 self.inside_record = 0 177 self.characters = self.ignore_characters
178
179 - def ignore_characters(self, s):
180 pass
181
182 -class ConvertDispatchHandler(Dispatch.Dispatcher):
183 """Used to read records and produce output through a Dispatcher"""
184 - def __init__(self, record_builder, writer, record_tag = "record"):
185 setattr(self, "end_" + record_tag, self.write_record) 186 Dispatch.Dispatcher.__init__(self, 187 remap = {record_tag: "bioformat:"} 188 ) 189 self.acquire(record_builder) 190 self.record_builder = record_builder 191 self.writer = writer 192 self.record_tag = record_tag
193 - def write_record(self, tag):
194 self.writer.write(self.record_builder.document)
195 196 197
198 -class RecognizeHandler(handler.ContentHandler, handler.ErrorHandler):
199 - def __init__(self):
200 self.recognized = 1 201 self.exc = None
202
203 - def fatalError(self, exc):
204 if isinstance(exc, Parser.ParserIncompleteException): 205 pass 206 else: 207 self.recognized = 0 208 self.exc = exc 209 raise exc
210 211 error = fatalError 212
213 - def endElement(self, tag):
214 if tag == "record": 215 raise Parser.ParserException("we finished a record!")
216 217 218
219 -class Handle_dbid(Dispatch.Callback):
220 - def start_dbid(self, tag, attrs):
221 self.attrs = attrs 222 self.save_characters()
223
224 - def end_dbid(self, tag):
225 text = self.get_characters() 226 self.callback(text, self.attrs)
227 228
229 -class Handle_description(Dispatch.Callback):
230 - def start_description_block(self, tag, attrs):
231 j = attrs.get("join", None) 232 if j is None: 233 self.join_fctn = Decode.join_fixspaces 234 else: 235 self.join_fctn = Decode.make_typechecked_decoder(j, list, str) 236 self.descriptions = []
237 - def start_description(self, tag, attrs):
238 self.save_characters()
239 - def end_description(self, tag):
240 x = self.get_characters() 241 self.descriptions.append(x)
242 - def end_description_block(self, tag):
243 self.callback(self.join_fctn(self.descriptions))
244 245 #### There can be multiple dbxref_dbids in a dbxref 246 # DR EMBL; X64411; CAA45756.1; -. 247 # <dbxref><..dbname style="swiss">EMBL</..dbname> 248 # <dbid type="primary">X64411</dbid> 249 # <dbid type="accession">CAA45756.1</dbid> 250 # </dbxref> 251 ### 252 # DR P35156, YPUI_BACSU, F; 253 # <dbxref><dbid type="primary" dbname="sprot">P35156</dbid> 254 # <dbid type="accession" dbname="sprot">YPUI_BACSU</dbid> 255 # <negate/> 256 # </dbxref> 257
258 -def _fixup_sp_pattern(exp):
259 import re 260 import Martel 261 exp = Martel.select_names(exp, (Std.dbxref_dbname.tag,Std.dbxref_dbid.tag)) 262 263 e = exp._find_groups(Std.dbxref_dbname.tag) 264 assert len(e) == 1 265 e = e[0] 266 e.name = "dbname" 267 dbstyle = e.attrs["style"] 268 e.attrs = {} 269 e = exp._find_groups(Std.dbxref_dbid.tag) 270 assert len(e) == 2 271 e[0].name = "primary_dbid" 272 primary_type = e[0].attrs["type"] 273 e[0].attrs = {} 274 e[1].name = "secondary_dbid" 275 secondary_type = e[1].attrs["type"] 276 e[1].attrs = {} 277 pattern = str(exp) + "$" 278 pat = re.compile(pattern) 279 return pat, dbstyle, primary_type, secondary_type
280 281 # Turns out these 'fast' versions speed up the dbxref code by about 282 # a factor of 2. 283 284 # DR PIR; S08427; S08427. 285 _fast_dbxref_sp_general_data = None
286 -def _fast_dbxref_sp_general(s):
287 global _fast_dbxref_sp_general_data 288 if _fast_dbxref_sp_general_data is None: 289 from Bio.expressions.swissprot import sprot38 290 _fast_dbxref_sp_general_data = _fixup_sp_pattern( 291 sprot38.real_DR_general) 292 293 pat, dbstyle, primary_type, secondary_type = _fast_dbxref_sp_general_data 294 295 m = pat.match(s) 296 assert m is not None, "Ill-formated sp-general dxbref: %r" % s 297 return ( 298 (dbstyle, m.group("dbname"), primary_type, 299 m.group("primary_dbid"), 0), 300 (dbstyle, m.group("dbname"), secondary_type, 301 m.group("secondary_dbid"), 0) 302 )
303 304 # DR PFAM; PF01018; GTP1_OBG; 1. 305 # DR PROSITE; PS00905; GTP1_OBG; 1. 306 307 _fast_dbxref_sp_prosite_data = None
308 -def _fast_dbxref_sp_prosite(s):
309 global _fast_dbxref_sp_prosite_data 310 311 if _fast_dbxref_sp_prosite_data is None: 312 from Bio.expressions.swissprot import sprot38 313 _fast_dbxref_sp_prosite_data = _fixup_sp_pattern( 314 sprot38.real_DR_prosite) 315 316 pat, dbstyle, primary_type, secondary_type = _fast_dbxref_sp_prosite_data 317 m = pat.match(s) 318 assert m is not None, "Ill-formated sp-prosite dxbref: %r" % s 319 return ( 320 (dbstyle, m.group("dbname"), primary_type, 321 m.group("primary_dbid"), 0), 322 (dbstyle, m.group("dbname"), secondary_type, 323 m.group("secondary_dbid"), 0) 324 )
325 326 327 # DR EMBL; M36407; AAA33110.1; -. 328 _fast_dbxref_sp_embl_data = None
329 -def _fast_dbxref_sp_embl(s):
330 global _fast_dbxref_sp_embl_data 331 332 if _fast_dbxref_sp_embl_data is None: 333 from Bio.expressions.swissprot import sprot38 334 _fast_dbxref_sp_embl_data = _fixup_sp_pattern( 335 sprot38.real_DR_embl) 336 337 pat, dbstyle, primary_type, secondary_type = _fast_dbxref_sp_embl_data 338 m = pat.match(s) 339 assert m is not None, "Ill-formated sp-embl dxbref: %r" % s 340 return ( 341 (dbstyle, m.group("dbname"), primary_type, 342 m.group("primary_dbid"), 0), 343 (dbstyle, m.group("dbname"), secondary_type, 344 m.group("secondary_dbid"), 0) 345 )
346 347 _fast_dbxref_parser_table = { 348 "sp-general": _fast_dbxref_sp_general, 349 "sp-prosite": _fast_dbxref_sp_prosite, 350 "sp-embl": _fast_dbxref_sp_embl, 351 } 352
353 -class Handle_dbxref(Dispatch.Callback):
354 - def __init__(self, callback):
355 Dispatch.Callback.__init__(self, callback) 356 self.supported_features.append("fast-sp-dbxref") 357 self.slow_callback = self.callback
358 - def start_dbxref(self, tag, attrs):
359 self.negate = 0 360 self.dbname = None 361 self.dbids = [] 362 self.info = []
363
364 - def start_dbxref_dbname(self, tag, attrs):
365 assert self.dbname is None, "cannot set the dbname twice" 366 self.dbname_style = attrs.get("style", "unknown") 367 self.save_characters()
368 - def end_dbxref_dbname(self, tag):
369 self.dbname = self.get_characters()
370
371 - def start_dbxref_dbid(self, tag, attrs):
372 d = attrs.get("dbname", None) 373 if d is None: 374 assert self.dbname is not None, "must set the dbname" 375 self.info.append( (self.dbname_style, self.dbname, 376 attrs.get("type", "primary")) ) 377 else: 378 self.info.append( ("bioformat", d, 379 attrs.get("type", "primary")) ) 380 self.save_characters()
381
382 - def end_dbxref_dbid(self, tag):
383 self.dbids.append( self.get_characters())
384
385 - def start_dbxref_negate(self, tag, attrs):
386 self.negate = 1
387
388 - def end_dbxref(self, tag):
389 cb = self.slow_callback 390 if cb is None: 391 return 392 negate = self.negate 393 for ( (dbname_style, dbname, idtype), dbid) in zip(self.info, 394 self.dbids): 395 self.slow_callback(dbname_style, dbname, idtype, dbid, negate)
396
397 - def start_fast_dbxref(self, tag, attrs):
398 style = attrs["style"] 399 self._fast_parser = _fast_dbxref_parser_table[style] 400 self.save_characters() 401 self.slow_callback = None
402 - def end_fast_dbxref(self, tag):
403 for info in self._fast_parser(self.get_characters()): 404 self.callback(*info) 405 self.slow_callback = self.callback
406 407 ##################
408 -class Handle_sequence(Dispatch.Callback):
409 global_alphabet = None
410 - def start_(self, tag, attrs):
411 self.global_alphabet = None
412
413 - def start_sequence_block(self, tag, attrs):
414 self.local_alphabet = attrs.get("alphabet", None) 415 self.gapchar = attrs.get("gapchar", None) 416 self.stopchar = attrs.get("stopchar", None) 417 j = attrs.get("join", None) 418 if j is not None: 419 self.join_func = Decode.make_typechecked_decoder(j, list, str) 420 else: 421 self.join_func = None 422 self.sequences = []
423
424 - def end_sequence_block(self, tag):
425 f = self.join_func 426 if f is not None: 427 seq = self.f(self.sequences) 428 else: 429 seq = "".join(self.sequences).replace(" ", "") 430 alphabet = self.local_alphabet or self.global_alphabet or "unknown" 431 self.callback( (alphabet, seq, self.gapchar, self.stopchar) )
432
433 - def start_alphabet(self, tag, attrs):
434 self.global_alphabet = attrs["alphabet"]
435
436 - def start_sequence(self, tag, attrs):
437 self.save_characters()
438 - def end_sequence(self, tag):
439 self.sequences.append(self.get_characters())
440
441 -class Feature:
442 - def __init__(self, name, description, location, qualifiers):
443 self.name = name 444 self.description = description 445 self.location = location 446 self.qualifiers = qualifiers
447 - def __str__(self):
448 return "Feature %r %r %s num_qualifiers = %d" % \ 449 (self.name, self.description, self.location, 450 len(self.qualifiers))
451 452
453 -class Handle_feature_location(Dispatch.Callback):
454 - def __init__(self, callback, settings = {}):
455 Dispatch.Callback.__init__(self, callback) 456 self.settings = settings
457
458 - def start_feature(self, tag, attrs):
459 self.location_style = attrs.get("location-style", 460 self.settings["location-style"]) 461 j = attrs.get("join-feature", None) 462 if j is None: 463 self.text_join_func = "".join 464 else: 465 self.text_join_func = Decode.make_typechecked_decoder(j, list, str) 466 467 self.location_start = None 468 self.location_end = None 469 self.text_lines = []
470
471 - def end_feature(self, tag):
472 if self.location_start or self.location_end: 473 if self.text_lines: 474 raise TypeError("Cannot have both location text and start/end") 475 self.callback(self.location_style, 476 (self.location_start, self.location_end)) 477 else: 478 self.callback(self.location_style, 479 (self.text_join_func(self.text_lines), None))
480
481 - def start_feature_location(self, tag, attrs):
482 self.save_characters()
483 - def end_feature_location(self, tag):
484 self.text_lines.append(self.get_characters())
485 486 add_text_handler(Handle_feature_location, "feature_location_start", 487 "location_start") 488 add_text_handler(Handle_feature_location, "feature_location_end", 489 "location_end") 490 491 ################################## 492
493 -class Handle_feature_qualifier(Dispatch.Callback):
494 - def __init__(self, callback, settings):
495 self.settings = settings 496 Dispatch.Callback.__init__(self, callback)
497
498 - def start_feature_qualifier(self, tag, attrs):
499 self.name = None 500 self.description = [] 501 qj = attrs.get("join-qualifier", None) 502 if qj is None: 503 self.join = self.settings["qualifier_join_func"] 504 else: 505 self.join = Decode.make_typechecked_decoder(qj, list, str)
506
507 - def end_feature_qualifier(self, tag):
508 self.callback(self.name, self.join(self.description))
509
510 - def start_feature_qualifier_description(self, tag, attrs):
511 self.save_characters()
514 515 add_text_handler(Handle_feature_qualifier, "feature_qualifier_name", "name") 516 517 #################### 518
519 -class Handle_features(Dispatch.Callback):
520 - def __init__(self, callback):
521 Dispatch.Callback.__init__(self, callback) 522 self.settings = {} 523 524 self.acquire(Handle_feature_location(self.add_location, self.settings)) 525 526 self.acquire(Handle_feature_qualifier(self.add_feature_qualifier, 527 self.settings))
528
529 - def start_feature_block(self, tag, attrs):
530 jf = attrs.get("join-description", None) 531 if jf is None: 532 self.join_feature_description = Decode.join_fixspaces 533 else: 534 self.join_feature_description = Decode.make_typechecked_decoder( 535 jf, list, str) 536 537 self.settings["location-style"] = attrs.get("location-style", None) 538 539 jq = attrs.get("join-qualifier", None) 540 if jq is None: 541 self.settings["qualifier_join_func"] = Decode.join_fixspaces 542 else: 543 self.settings["qualifier_join_func"] = \ 544 Decode.make_typechecked_decoder(jq, list, str) 545 self.features = []
546
547 - def end_feature_block(self, tag):
548 self.callback(self.features) 549 self.features = None
550
551 - def start_feature(self, tag, attrs):
552 self.name = None 553 self.description = [] 554 self.location = None 555 self.qualifiers = []
556
557 - def start_feature_description(self, tag, attrs):
558 self.save_characters()
559 - def end_feature_description(self, tag):
561
562 - def end_feature(self, tag):
563 self.features.append(Feature( 564 self.name, 565 self.join_feature_description(self.description), 566 self.location, 567 self.qualifiers))
568
569 - def add_feature_qualifier(self, name, description):
570 self.qualifiers.append((name, description))
571
572 - def add_location(self, style, location_info):
573 self.location = (style, location_info)
574 575 add_text_handler(Handle_features, "feature_name", "name") 576 577 578 ############## Search handlers 579
580 -class Handle_hsp_seqalign(Dispatch.Callback):
581 - def start_hsp(self, tag, attrs):
582 self.query_name = None # "Query" 583 self.subject_name = None # "Sbjct" 584 585 self.query_seq = "" # the actual text of the sequence 586 self.homology_seq = "" 587 self.subject_seq = "" 588 589 self.query_start_loc = None 590 self.query_end_loc = None 591 592 self.subject_start_loc = None 593 self.subject_end_loc = None
594
595 - def end_hsp(self, tag):
596 self.callback(self)
597
598 - def start_hsp_seqalign(self, tag, attrs):
599 self.sub_leader = None
600
601 - def start_hsp_seqalign_query_seq(self, tag, attrs):
602 self.save_characters()
603 - def end_hsp_seqalign_query_seq(self, tag):
604 s = self.get_characters() 605 self.query_seq += s 606 self.sub_query_seq_len = len(s)
607
608 - def start_hsp_seqalign_homology_seq(self, tag, attrs):
609 self.save_characters()
610 - def end_hsp_seqalign_homology_seq(self, tag):
611 query_leader = self.leader_size 612 query_seq_len = self.sub_query_seq_len 613 line = self.get_characters() 614 s = line[query_leader:query_leader+query_seq_len] 615 assert len(s) == query_seq_len, (len(s), query_seq_len, line) 616 self.homology_seq += s
617
618 - def start_hsp_seqalign_subject_seq(self, tag, attrs):
619 self.save_characters()
620 - def end_hsp_seqalign_subject_seq(self, tag):
621 self.subject_seq += self.get_characters()
622
623 - def start_hsp_seqalign_query_leader(self, tag, attrs):
624 self.save_characters()
625 - def end_hsp_seqalign_query_leader(self, tag):
626 self.leader_size = len(self.get_characters())
627 628 add_first_text_handler(Handle_hsp_seqalign, "hsp_seqalign_query_name", 629 "query_name") 630 631 add_first_text_handler(Handle_hsp_seqalign, "hsp_seqalign_subject_name", 632 "subject_name") 633 634 add_first_text_handler(Handle_hsp_seqalign, "hsp_seqalign_query_start", 635 "query_start_loc") 636 add_text_handler(Handle_hsp_seqalign, "hsp_seqalign_query_end", 637 "query_end_loc") 638 639 add_first_text_handler(Handle_hsp_seqalign, "hsp_seqalign_subject_start", 640 "subject_start_loc") 641 add_text_handler(Handle_hsp_seqalign, "hsp_seqalign_subject_end", 642 "subject_end_loc") 643 644 645 646 647 ############################# 648
649 -class Handle_hsp(Dispatch.Callback):
650 - def __init__(self, callback):
651 Dispatch.Callback.__init__(self, callback) 652 self.acquire(Handle_hsp_seqalign(self.add_hsp_seqs))
653
654 - def start_hsp(self, tag, attrs):
655 self.hsp_values = {} # expect, p, identities, ... 656 self.strands = {} 657 self.frames = {}
658
659 - def end_hsp(self, tag):
660 self.callback(self.hsp_values, 661 self.hsp_info, 662 self.strands, self.frames, 663 )
664
665 - def start_hsp_strand(self, tag, attrs):
666 self.strands[attrs["which"]] = attrs["strand"]
667
668 - def start_hsp_frame(self, tag, attrs):
669 self.getting_frame = attrs["which"] 670 self.save_characters()
671
672 - def end_hsp_frame(self, tag):
673 self.frames[self.getting_frame] = self.get_characters() 674 self.getting_frame = None
675
676 - def add_hsp_seqs(self, hsp_info):
677 self.hsp_info = hsp_info
678
679 - def start_hsp_value(self, tag, attrs):
680 self.value_convert = attrs.get("bioformat:decode", None) 681 self.value_name = attrs["name"] 682 self.save_characters()
683
684 - def end_hsp_value(self, tag):
685 s = self.get_characters() 686 if self.value_name is not None: 687 if self.value_name == "float": 688 s = float(s) 689 else: 690 s = Decode.make_decoder(self.value_convert)(s) 691 self.hsp_values[self.value_name] = s
692 693 ############################# 694 695
696 -class Handle_search_table(Dispatch.Callback):
697 - def start_search_table_value(self, tag, attrs):
698 self.value_name = attrs["name"] 699 self.value_decode = attrs.get("bioformat:decode", None) 700 self.save_characters()
701 - def end_search_table_value(self, tag):
702 s = self.get_characters() 703 if self.value_decode is not None: 704 x = self.value_decode 705 if x == "int": 706 s = int(s) 707 elif x == "float": 708 s = float(s) 709 else: 710 s = Decode.make_decoder(x)(s) 711 self.values[self.value_name] = s
712
713 - def start_search_table(self, tag, attrs):
714 self.data = []
715 - def end_search_table(self, tag):
716 self.callback(self.data) 717 self.data = None
718
719 - def start_search_table_entry(self, tag, attrs):
720 self.description = None 721 self.values = {}
722
723 - def end_search_table_entry(self, tag):
724 self.data.append( (self.description, self.values) ) 725 self.description = self.values = None
726 727 add_text_handler(Handle_search_table, "search_table_description", 728 "description") 729 730 ############################# 731
732 -class Handle_search_header(Dispatch.Callback):
733 - def start_(self, tag, attrs):
734 self.dict = {} 735 self.query_description = None
736
737 - def end_search_header(self, tag):
738 d = self.dict 739 d["query_description"] = self.query_description 740 self.callback(d)
741 742 add_text_block_handler(Handle_search_header, "query_description", 743 "join-query", "join|fixspaces", "query_description") 744 745 add_text_dict_handler(Handle_search_header, "application_name", 746 "dict", "appname") 747 add_text_dict_handler(Handle_search_header, "application_version", 748 "dict", "appversion") 749 add_text_dict_handler(Handle_search_header, "database_name", 750 "dict", "dbname") 751 add_text_dict_handler(Handle_search_header, "database_num_sequences", 752 "dict", "db_num_sequences") 753 add_text_dict_handler(Handle_search_header, "database_num_letters", 754 "dict", "db_num_letters") 755 add_text_dict_handler(Handle_search_header, "query_size", 756 "dict", "query_size") 757 758 759 ############################# 760
761 -class Handle_search_info(Dispatch.Callback):
762 - def start_(self, tag, attrs):
763 self.parameters = {} 764 self.statistics = {}
765
766 - def end_(self, tag):
767 self.callback(self.parameters, self.statistics)
768 769 add_value_handler(Handle_search_info, "search_parameter", "parameters") 770 add_value_handler(Handle_search_info, "search_statistic", "statistics") 771