+++ /dev/null
-# This is a Python module.
-"""This module is DEPRECATED.
-
-Andrew Dalke is no longer maintaining Martel or Bio.Mindy, and these modules
-and associate ones like Bio.Std are now deprecated. They are no longer
-used in any of the current Biopython parsers, and are likely to be removed
-in a future release.
-"""
-
-import warnings
-warnings.warn("Martel and those parts of Biopython depending on it" \
- +" directly (such as Bio.Mindy and Bio.Std) are now" \
- +" deprecated, and will be removed in a future release of"\
- +" Biopython. If you want to continue to use this code,"\
- +" please get in contact with the Biopython developers via"\
- +" the mailing lists to avoid its permanent removal from"\
- +" Biopython.", \
- DeprecationWarning)
-# Standard Bioformats definitions
-
-import Martel
-Group = Martel.Group
-
-namespace = "bioformat"
-NS = namespace + ":"
-XMLNS = "http://biopython.org/bioformat"
-
-def _set_if_given(attrs, field, d, valid = None, convert = None):
- value = attrs.get(field)
- if value is not None:
- if valid is not None:
- if value not in valid:
- raise TypeError("%s (%r) must be one of %s" % \
- (field, value, valid))
- if convert is None:
- d[field] = value
- else:
- d[field] = convert(value)
-
-def _complain_if_given(attrs, name):
- if attrs.has_key(name) and attrs[name] is not None:
- raise NotImplementedError("Don't yet handle %r" % (name,))
-
-def _must_have(expr, f):
- tag = f.tag
- if tag not in expr.group_names():
- raise TypeError(
- "group %r not present in the expression but is required" % \
- (tag,))
-
-def _must_have_set(expr, sets):
- names = expr.group_names()
- for set in sets:
- for f in set:
- tag = f.tag
- if tag not in names:
- break
- else:
- return
- if len(sets) == 1:
- raise TypeError("missing required tags (need %s) in expression" %
- [f.tag for f in sets[0]])
- lines = ["missing required tags in expression; must have one set from:"]
- for set in sets:
- lines.append( str( [t.tag for f in set] ) )
- s = "\n".join(lines)
- raise TypeError(s)
-
-def _must_not_have(expr, f):
- f.tag
- if tag in expr.group_names():
- raise TypeError(
- "group %r present in the expression but is not allowed" % \
- (tag,))
-
-
-# pre- Python 2.2 functions didn't allow attributes
-def _f():
- pass
-try:
- _f.x = 1
- _use_hack = 0
-except AttributeError:
- _use_hack = 1
-del _f
-
-def _check_name(f, text):
- if text == "record": # XXX FIXME
- return
- assert NS + f.func_name == text, (NS + ":" + f.func_name, text)
-
-def _check_attrs(attrs, names):
- for name in attrs.keys():
- if name not in names:
- raise TypeError("attr %r is not allowed here (valid terms: %s)" % \
- (name, names))
- d = attrs.copy()
- for name in names:
- if not d.has_key(name):
- d[name] = None
- return d
-
-if not _use_hack:
- def _settag(f, tag):
- _check_name(f, tag)
- f.tag = tag
-else:
- # Convert the functions into callable objects
- class StdTerm:
- def __init__(self, func):
- self._func = func
- def __call__(self, *args, **kwargs):
- return self._func( *args, **kwargs)
-
- def _settag(f, tag):
- _check_name(f, tag)
- x = globals()[f.func_name] = StdTerm(f)
- x.tag = tag
-
-################ identifier, description, and cross-references
-def record(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("format",))
- d = {"xmlns:bioformat": XMLNS}
- _set_if_given(attrs, "format", d)
- return Group("record", expr, d) # XXX FIXME
-_settag(record, "record") # XXX AND FIXME
-
-
-def dbid(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("type", "style", "dbname"))
- d = {}
- _set_if_given(attrs, "type", d, ("primary", "accession", "secondary"))
- _set_if_given(attrs, "dbname", d)
- return Group(NS + "dbid", expr, d)
-_settag(dbid, NS + "dbid")
-
-def description_block(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("join",))
- _must_have(expr, description)
- d = {}
- _set_if_given(attrs, "join", d, ("english", "concat", "space", "newline"))
- return Group(NS + "description_block", expr, d)
-_settag(description_block, NS + "description_block")
-
-def description(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "description", expr)
-_settag(description, NS + "description")
-
-def description_line(expr, attrs = {}):
- return description_block(description(expr, attrs))
-
-def fast_dbxref(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("style",))
- d = {}
- _set_if_given(attrs, "style", d, ("sp-general", "sp-prosite", "sp-embl"))
- return Group(NS + "fast_dbxref", expr, d)
-
-def dbxref(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("style",))
- _must_have(expr, dbxref_dbid)
- d = {}
- _complain_if_given(attrs, "style")
- return Group(NS + "dbxref", expr, d)
-_settag(dbxref, NS + "dbxref")
-
-def dbxref_dbname(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("style",))
- d = {}
- _set_if_given(attrs, "style", d)
- return Group(NS + "dbxref_dbname", expr, d)
-_settag(dbxref_dbname, NS + "dbxref_dbname")
-
-def dbxref_dbid(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("dbname", "type", "style", "negate"))
- d = {}
- _set_if_given(attrs, "dbname", d)
- _set_if_given(attrs, "type", d, ("primary", "accession", "secondary"))
- _complain_if_given(attrs, "style")
- _set_if_given(attrs, "negate", d, (0, 1), str)
-
- return Group(NS + "dbxref_dbid", expr, d)
-_settag(dbxref_dbid, NS + "dbxref_dbid")
-
-def dbxref_negate(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "dbxref_negate", expr)
-_settag(dbxref_negate, NS + "dbxref_negate")
-
-##################### sequences
-
-def _check_gapchar(s):
- if not ( ord(" ") <= ord(s) <= 126 ):
- raise TypeError("%r not allowed as a gap character" % (s,))
- return s
-
-# What about three letter codes?
-def sequence_block(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("alphabet", "gapchar", "remove_spaces"))
- _must_have(expr, sequence)
- d = {}
- _set_if_given(attrs, "alphabet", d,
- ("iupac-protein", "iupac-dna", "iupac-rna",
- "iupac-ambiguous-protein",
- "iupac-ambiguous-dna",
- "iupac-ambiguous-rna",
- "protein", "dna", "rna", "unknown"))
- _set_if_given(attrs, "gapchar", d, convert = _check_gapchar)
- _set_if_given(attrs, "remove_spaces", d, (0, 1), str)
- return Group(NS + "sequence_block", expr, d)
-_settag(sequence_block, NS + "sequence_block")
-
-def sequence(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "sequence", expr)
-_settag(sequence, NS + "sequence")
-
-def alphabet(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("alphabet",))
- d = {}
- _set_if_given(attrs, "alphabet", d,
- ("iupac-protein", "iupac-dna", "iupac-rna",
- "iupac-ambiguous-protein",
- "iupac-ambiguous-dna",
- "iupac-ambiguous-rna",
- "protein", "dna", "rna", "nucleotide", "unknown"))
- return Group(NS + "alphabet", expr, d)
-_settag(alphabet, NS + "alphabet")
-
-
-
-############################## features
-
-# In PIR
-
-# FEATURE
-# 1-25 #domain signal sequence #status predicted #label SIG\
-# 26-737 #product procollagen-lysine 5-dioxygenase 2 #status
-# predicted #label MAT\
-# 63,209,297,365,522,
-# 725 #binding_site carbohydrate (Asn) (covalent) #status
-# predicted
-
-# The whole thing is a 'feature_block'
-
-# One 'feature' is
-# 26-737 #product procollagen-lysine 5-dioxygenase 2 #status
-# predicted #label MAT\
-
-# One 'feature_name' is "binding_site".
-
-# An example of the feature_location_block and feature_block, which I
-# will abbreviate as 'flb' and 'fl', is:
-# <flb> <fl>63,209,297,365,522,</fl>
-# <fl>725</fl> #binding_site carbohydrate ...
-
-# PIR doesn't have a 'feature_description'
-
-# Let:
-# fq = feature_qualifier
-# fqb = feature_qualifier
-# fqn = feature_qualifier_name
-# fqd = feature_qualifier_description
-# then the text
-#
-# 26-737 #product procollagen-lysine 5-dioxygenase 2 #status
-# predicted #label MAT\
-#
-# can be represented as (the rather tedious)
-#
-# 26-737 <fqb><fq>#<fqn>product</fqn> <fqd>procollagen-\
-# lysine 5-dioxygenase 2</fqd></fq> #<fq><fqn>status</fqn>
-# <fqd>predicted</fqd> #<fq><fqn>label\
-# </fqn> <fqd>MAT</fqd></fq>\</fqb>
-#
-
-# 'style' determines the namespace for the feature name
-def feature_block(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("style", "location-style"))
- d = {}
- _set_if_given(attrs, "style", d)
- _set_if_given(attrs, "location-style", d)
- _must_have(expr, feature)
- return Group(NS + "feature_block", expr, d)
-_settag(feature_block, NS + "feature_block")
-
-def feature(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("location-style",))
- d = {}
- _set_if_given(attrs, "location-style", d)
- _must_have(expr, feature_name)
- _must_have_set(expr, [[feature_location],
- [feature_location_start, feature_location_end]])
- return Group(NS + "feature", expr, d)
-_settag(feature, NS + "feature")
-
-def feature_name(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "feature_name", expr)
-_settag(feature_name, NS + "feature_name")
-
-def feature_location(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "feature_location", expr)
-_settag(feature_location, NS + "feature_location")
-
-def feature_location_start(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "feature_location_start", expr)
-_settag(feature_location_start, NS + "feature_location_start")
-
-def feature_location_end(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "feature_location_end", expr)
-_settag(feature_location_end, NS + "feature_location_end")
-
-def feature_description(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "feature_description", expr)
-_settag(feature_description, NS + "feature_description")
-
-
-##def feature_qualifier_block(expr, attrs = {}):
-## attrs = _check_attrs(attrs, ())
-## _must_have(expr, feature_qualifier)
-## return Group(NS + "feature_qualifier_block", expr)
-##_settag(feature_qualifier_block, NS + "feature_qualifier_block")
-
-def feature_qualifier(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- _must_have(expr, feature_qualifier_name)
- return Group(NS + "feature_qualifier", expr)
-_settag(feature_qualifier, NS + "feature_qualifier")
-
-def feature_qualifier_name(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "feature_qualifier_name", expr)
-_settag(feature_qualifier_name, NS + "feature_qualifier_name")
-
-def feature_qualifier_description(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group(NS + "feature_qualifier_description", expr)
-_settag(feature_qualifier_description, NS + "feature_qualifier_description")
-
-
-############ For homology searches
-
-# "BLASTN", "BLASTP"
-def application_name(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("app",))
- return Group("bioformat:application_name", expr, attrs)
-
-# "2.0.11", "2.0a19MP-WashU"
-def application_version(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:application_version", expr, attrs)
-
-def search_header(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:search_header", expr, attrs)
-
-def search_table(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:search_table", expr, attrs)
-
-def search_table_description(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("bioformat:decode",))
- d = {"bioformat:decode": "strip"}
- _set_if_given(attrs, "bioformat:decode", d)
- return Group("bioformat:search_table_description", expr, d)
-
-def search_table_value(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("name", "bioformat:decode"))
- return Group("bioformat:search_table_value", expr, attrs)
-
-def search_table_entry(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:search_table_entry", expr, attrs)
-
-def query_description_block(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("join-query",))
- d = {"join-query": "join|fixspaces"}
- _set_if_given(attrs, "join-query", d)
- return Group("bioformat:query_description_block", expr, d)
-
-def query_description(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("bioformat:decode"))
- d = {}
- _set_if_given(attrs, "bioformat:decode", d)
- return Group("bioformat:query_description", expr, d)
-
-def query_size(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:query_size", expr)
-
-def database_name(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:database_name", expr, attrs)
-
-def database_num_sequences(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("bioformat:decode",))
- return Group("bioformat:database_num_sequences", expr, attrs)
-
-def database_num_letters(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("bioformat:decode",))
- return Group("bioformat:database_num_letters", expr, attrs)
-
-def hit(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("join-description",))
- d = {"join-description": "join|fixspaces"}
- _set_if_given(attrs, "join-description", d)
- return Group("bioformat:hit", expr, d)
-
-def hit_length(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hit_length", expr, attrs)
-
-def hit_description(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("bioformat:decode"))
- d = {}
- _set_if_given(attrs, "bioformat:decode", d)
- return Group("bioformat:hit_description", expr, d)
-
-def hsp(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp", expr, attrs)
-
-def hsp_value(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("name", "bioformat:decode"))
- return Group("bioformat:hsp_value", expr, attrs)
-
-def hsp_frame(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("which",))
- d = {}
- _set_if_given(attrs, "which", d, valid = ("query", "homology", "subject"))
- return Group("bioformat:hsp_frame", expr, d)
-
-def hsp_strand(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("strand", "which"))
- d = {}
- _set_if_given(attrs, "which", d, valid = ("query", "homology", "subject"))
- _set_if_given(attrs, "strand", d, valid = ("+1", "0", "-1", ""))
- return Group("bioformat:hsp_strand", expr, d)
-
-def hsp_seqalign_query_seq(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_query_seq", expr, attrs)
-
-def hsp_seqalign_homology_seq(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_homology_seq", expr, attrs)
-
-def hsp_seqalign_subject_seq(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_subject_seq", expr, attrs)
-
-def hsp_seqalign_query_leader(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_query_leader", expr, attrs)
-
-
-def hsp_seqalign_query_name(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_query_name", expr, attrs)
-
-def hsp_seqalign_subject_name(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_subject_name", expr, attrs)
-
-def hsp_seqalign(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign", expr, attrs)
-
-def hsp_seqalign_query_start(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_query_start", expr, attrs)
-
-def hsp_seqalign_query_end(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_query_end", expr, attrs)
-
-def hsp_seqalign_subject_start(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_subject_start", expr, attrs)
-
-def hsp_seqalign_subject_end(expr, attrs = {}):
- attrs = _check_attrs(attrs, ())
- return Group("bioformat:hsp_seqalign_subject_end", expr, attrs)
-
-def search_parameter(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("name", "bioformat:decode"))
- d = {}
- _set_if_given(attrs, "name", d)
- _set_if_given(attrs, "bioformat:decode", d)
- return Group("bioformat:search_parameter", expr, d)
-
-def search_statistic(expr, attrs = {}):
- attrs = _check_attrs(attrs, ("name", "bioformat:decode"))
- d = {}
- _set_if_given(attrs, "name", d)
- _set_if_given(attrs, "bioformat:decode", d)
- return Group("bioformat:search_statistic", expr, d)
-
git://source.jalview.org / jabaws.git / blobdiff