--- /dev/null
+"""Represent a Sequence Feature holding info about a part of a sequence.
+
+This is heavily modeled after the Biocorba SeqFeature objects, and
+may be pretty biased towards GenBank stuff since I'm writing it
+for the GenBank parser output...
+
+What's here:
+
+Base class to hold a Feature.
+----------------------------
+classes:
+o SeqFeature
+
+Hold information about a Reference.
+----------------------------------
+
+This is an attempt to create a General class to hold Reference type
+information.
+
+classes:
+o Reference
+
+Specify locations of a feature on a Sequence.
+---------------------------------------------
+
+This aims to handle, in Ewan's words, 'the dreaded fuzziness issue' in
+much the same way as Biocorba. This has the advantages of allowing us
+to handle fuzzy stuff in case anyone needs it, and also be compatible
+with Biocorba.
+
+classes:
+o FeatureLocation - Specify the start and end location of a feature.
+
+o ExactPosition - Specify the position as being exact.
+o WithinPosition - Specify a position occuring within some range.
+o BetweenPosition - Specify a position occuring between a range.
+o BeforePosition - Specify the position as being found before some base.
+o AfterPosition - Specify the position as being found after some base.
+"""
+
+class SeqFeature:
+ """Represent a Sequence Feature on an object.
+
+ Attributes:
+ o location - the location of the feature on the sequence
+ o type - the specified type of the feature (ie. CDS, exon, repeat...)
+ o location_operator - a string specifying how this SeqFeature may
+ be related to others. For example, in the example GenBank feature
+ shown below, the location_operator would be "join"
+ o strand - A value specifying on which strand (of a DNA sequence, for
+ instance) the feature deals with. 1 indicates the plus strand, -1
+ indicates the minus strand, 0 indicates both strands, and None indicates
+ that strand doesn't apply (ie. for proteins) or is not known.
+ o id - A string identifier for the feature.
+ o ref - A reference to another sequence. This could be an accession
+ number for some different sequence.
+ o ref_db - A different database for the reference accession number.
+ o qualifier - A dictionary of qualifiers on the feature. These are
+ analagous to the qualifiers from a GenBank feature table. The keys of
+ the dictionary are qualifier names, the values are the qualifier
+ values.
+ o sub_features - Additional SeqFeatures which fall under this 'parent'
+ feature. For instance, if we having something like:
+
+ CDS join(1..10,30..40,50..60)
+
+ The the top level feature would be a CDS from 1 to 60, and the sub
+ features would be of 'CDS_join' type and would be from 1 to 10, 30 to
+ 40 and 50 to 60, respectively.
+ """
+ def __init__(self, location = None, type = '', location_operator = '',
+ strand = None, id = "<unknown id>",
+ qualifiers = {}, sub_features = [],
+ ref = None, ref_db = None):
+ """Initialize a SeqFeature on a Sequence.
+ """
+ self.location = location
+
+ self.type = type
+ self.location_operator = location_operator
+ self.strand = strand
+ self.id = id
+ # XXX right now sub_features and qualifiers cannot be set
+ # from the initializer because this causes all kinds
+ # of recursive import problems. I can't understand why this is
+ # at all :-<
+ self.qualifiers = {}
+ self.sub_features = []
+ self.ref = ref
+ self.ref_db = ref_db
+
+ def __repr__(self):
+ """A string representation of the record for debugging."""
+ answer = "%s(%s" % (self.__class__, repr(self.location))
+ if self.type :
+ answer += ", type=%s" % repr(self.type)
+ if self.location_operator :
+ answer += ", location_operator=%s" % repr(self.location_operator)
+ if self.strand :
+ answer += ", strand=%s" % repr(self.strand)
+ if self.id and self.id != "<unknown id>" :
+ answer += ", id=%s" % repr(self.id)
+ if self.ref :
+ answer += ", ref=%s" % repr(self.ref)
+ if self.ref_db :
+ answer += ", ref_db=%s" % repr(self.ref_db)
+ answer += ")"
+ return answer
+
+ def __str__(self):
+ """A readable summary of the feature intended to be printed to screen.
+ """
+ out = "type: %s\n" % self.type
+ out += "location: %s\n" % self.location
+ out += "ref: %s:%s\n" % (self.ref, self.ref_db)
+ out += "strand: %s\n" % self.strand
+ out += "qualifiers: \n"
+ qualifier_keys = self.qualifiers.keys()
+ qualifier_keys.sort()
+ for qual_key in qualifier_keys:
+ out += "\tKey: %s, Value: %s\n" % (qual_key,
+ self.qualifiers[qual_key])
+ if len(self.sub_features) != 0:
+ out += "Sub-Features\n"
+ for sub_feature in self.sub_features:
+ out +="%s\n" % sub_feature
+
+ return out
+
+ def _shift(self, offset) :
+ """Returns a copy of the feature with its location shifted (PRIVATE).
+
+ The annotation qaulifiers are copied."""
+ answer = SeqFeature(location = self.location._shift(offset),
+ type = self.type,
+ location_operator = self.location_operator,
+ strand = self.strand,
+ id = self.id,
+ #qualifiers = dict(self.qualifiers.iteritems()),
+ #sub_features = [f._shift(offset) for f in self.sub_features],
+ ref = self.ref,
+ ref_db = self.ref_db)
+ #TODO - Sort out the use of sub_feature and qualifiers in __init___
+ answer.sub_features = [f._shift(offset) for f in self.sub_features]
+ answer.qualifiers = dict(self.qualifiers.iteritems())
+ return answer
+
+# --- References
+
+# TODO -- Will this hold PubMed and Medline information decently?
+class Reference:
+ """Represent a Generic Reference object.
+
+ Attributes:
+ o location - A list of Location objects specifying regions of
+ the sequence that the references correspond to. If no locations are
+ specified, the entire sequence is assumed.
+ o authors - A big old string, or a list split by author, of authors
+ for the reference.
+ o title - The title of the reference.
+ o journal - Journal the reference was published in.
+ o medline_id - A medline reference for the article.
+ o pubmed_id - A pubmed reference for the article.
+ o comment - A place to stick any comments about the reference.
+ """
+ def __init__(self):
+ self.location = []
+ self.authors = ''
+ self.consrtm = ''
+ self.title = ''
+ self.journal = ''
+ self.medline_id = ''
+ self.pubmed_id = ''
+ self.comment = ''
+
+ def __str__(self):
+ """Output an informative string for debugging.
+ """
+ out = ""
+ for single_location in self.location:
+ out += "location: %s\n" % single_location
+ out += "authors: %s\n" % self.authors
+ if self.consrtm:
+ out += "consrtm: %s\n" % self.consrtm
+ out += "title: %s\n" % self.title
+ out += "journal: %s\n" % self.journal
+ out += "medline id: %s\n" % self.medline_id
+ out += "pubmed id: %s\n" % self.pubmed_id
+ out += "comment: %s\n" % self.comment
+
+ return out
+
+# --- Handling feature locations
+
+class FeatureLocation:
+ """Specify the location of a feature along a sequence.
+
+ This attempts to deal with fuzziness of position ends, but also
+ make it easy to get the start and end in the 'normal' case (no
+ fuzziness).
+
+ You should access the start and end attributes with
+ your_location.start and your_location.end. If the start and
+ end are exact, this will return the positions, if not, we'll return
+ the approriate Fuzzy class with info about the position and fuzziness.
+
+ Note that the start and end location numbering follow Python's scheme,
+ thus a GenBank entry of 123..150 (one based counting) becomes a location
+ of [122:150] (zero based counting).
+ """
+ def __init__(self, start, end):
+ """Specify the start and end of a sequence feature.
+
+ start and end arguments specify the values where the feature begins
+ and ends. These can either by any of the *Position objects that
+ inherit from AbstractPosition, or can just be integers specifying the
+ position. In the case of integers, the values are assumed to be
+ exact and are converted in ExactPosition arguments. This is meant
+ to make it easy to deal with non-fuzzy ends.
+ """
+ if isinstance(start, AbstractPosition):
+ self._start = start
+ else:
+ self._start = ExactPosition(start)
+
+ if isinstance(end, AbstractPosition):
+ self._end = end
+ else:
+ self._end = ExactPosition(end)
+
+ def __str__(self):
+ """Returns a representation of the location (with python counting).
+
+ For the simple case this uses the python splicing syntax, [122:150]
+ (zero based counting) which GenBank would call 123..150 (one based
+ counting).
+ """
+ return "[%s:%s]" % (self._start, self._end)
+
+ def __repr__(self):
+ """A string representation of the location for debugging."""
+ return "%s(%s,%s)" \
+ % (self.__class__, repr(self.start), repr(self.end))
+
+ def _shift(self, offset) :
+ """Returns a copy of the location shifted by the offset (PRIVATE)."""
+ return FeatureLocation(start = self._start._shift(offset),
+ end = self._end._shift(offset))
+
+ def __getattr__(self, attr):
+ """Make it easy to get non-fuzzy starts and ends.
+
+ We override get_attribute here so that in non-fuzzy cases we
+ can just return the start and end position without any hassle.
+
+ To get fuzzy start and ends, just ask for item.start and
+ item.end. To get non-fuzzy attributes (ie. the position only)
+ ask for 'item.nofuzzy_start', 'item.nofuzzy_end'. These should return
+ the largest range of the fuzzy position. So something like:
+ (10.20)..(30.40) should return 10 for start, and 40 for end.
+
+ The special tricky case where is when we have a single between position
+ argument like 2^3 for the range. We want nofuzzy_start and nofuzzy_end
+ to give a reasonable approximation of what this really means, which
+ is an empty string -- so the same position for both. Doing a special
+ case here sucks, but there is really not a general rule you can apply
+ to this.
+ """
+ #TODO - these are not currently implemented as properties, this means
+ #they do not show up via dir(...)
+ if attr == 'start':
+ return self._start
+ elif attr == 'end':
+ return self._end
+ elif attr == 'nofuzzy_start':
+ if ((self._start == self._end) and isinstance(self._start,
+ BetweenPosition)):
+ return self._start.position
+ else:
+ return min(self._start.position,
+ self._start.position + self._start.extension)
+ elif attr == 'nofuzzy_end':
+ if ((self._start == self._end) and isinstance(self._start,
+ BetweenPosition)):
+ return self._end.position
+ else:
+ return max(self._end.position,
+ self._end.position + self._end.extension)
+ else:
+ raise AttributeError("Cannot evaluate attribute %s." % attr)
+
+class AbstractPosition:
+ """Abstract base class representing a position.
+ """
+ def __init__(self, position, extension):
+ self.position = position
+ self.extension = extension
+
+ def __repr__(self) :
+ """String representation of the location for debugging."""
+ return "%s(%s,%s)" \
+ % (self.__class__, repr(self.position), repr(self.extension))
+
+ def __cmp__(self, other):
+ """A simple comparison function for positions.
+
+ This is very simple-minded and just compares the position attribute
+ of the features; extensions are not considered at all. This could
+ potentially be expanded to try to take advantage of extensions.
+ """
+ assert isinstance(other, AbstractPosition), \
+ "We can only do comparisons between Biopython Position objects."
+
+ return cmp(self.position, other.position)
+
+ def _shift(self, offset) :
+ #We want this to maintain the subclass when called from a subclass
+ return self.__class__(self.position + offset, self.extension)
+
+class ExactPosition(AbstractPosition):
+ """Specify the specific position of a boundary.
+
+ o position - The position of the boundary.
+ o extension - An optional argument which must be zero since we don't
+ have an extension. The argument is provided so that the same number of
+ arguments can be passed to all position types.
+
+ In this case, there is no fuzziness associated with the position.
+ """
+ def __init__(self, position, extension = 0):
+ if extension != 0:
+ raise AttributeError("Non-zero extension %s for exact position."
+ % extension)
+ AbstractPosition.__init__(self, position, 0)
+
+ def __repr__(self) :
+ """String representation of the ExactPosition location for debugging."""
+ assert self.extension == 0
+ return "%s(%s)" % (self.__class__, repr(self.position))
+
+ def __str__(self):
+ return str(self.position)
+
+class WithinPosition(AbstractPosition):
+ """Specify the position of a boundary within some coordinates.
+
+ Arguments:
+ o position - The start position of the boundary
+ o extension - The range to which the boundary can extend.
+
+ This allows dealing with a position like ((1.4)..100). This
+ indicates that the start of the sequence is somewhere between 1
+ and 4. To represent that with this class we would set position as
+ 1 and extension as 3.
+ """
+ def __init__(self, position, extension = 0):
+ AbstractPosition.__init__(self, position, extension)
+
+ def __str__(self):
+ return "(%s.%s)" % (self.position, self.position + self.extension)
+
+class BetweenPosition(AbstractPosition):
+ """Specify the position of a boundary between two coordinates.
+
+ Arguments:
+ o position - The start position of the boundary.
+ o extension - The range to the other position of a boundary.
+
+ This specifies a coordinate which is found between the two positions.
+ So this allows us to deal with a position like ((1^2)..100). To
+ represent that with this class we set position as 1 and the
+ extension as 1.
+ """
+ def __init__(self, position, extension = 0):
+ AbstractPosition.__init__(self, position, extension)
+
+ def __str__(self):
+ return "(%s^%s)" % (self.position, self.position + self.extension)
+
+class BeforePosition(AbstractPosition):
+ """Specify a position where the actual location occurs before it.
+
+ Arguments:
+ o position - The upper boundary of where the location can occur.
+ o extension - An optional argument which must be zero since we don't
+ have an extension. The argument is provided so that the same number of
+ arguments can be passed to all position types.
+
+ This is used to specify positions like (<10..100) where the location
+ occurs somewhere before position 10.
+ """
+ def __init__(self, position, extension = 0):
+ if extension != 0:
+ raise AttributeError("Non-zero extension %s for exact position."
+ % extension)
+ AbstractPosition.__init__(self, position, 0)
+
+ def __repr__(self) :
+ """A string representation of the location for debugging."""
+ assert self.extension == 0
+ return "%s(%s)" % (self.__class__, repr(self.position))
+
+ def __str__(self):
+ return "<%s" % self.position
+
+class AfterPosition(AbstractPosition):
+ """Specify a position where the actual location is found after it.
+
+ Arguments:
+ o position - The lower boundary of where the location can occur.
+ o extension - An optional argument which must be zero since we don't
+ have an extension. The argument is provided so that the same number of
+ arguments can be passed to all position types.
+
+ This is used to specify positions like (>10..100) where the location
+ occurs somewhere after position 10.
+ """
+ def __init__(self, position, extension = 0):
+ if extension != 0:
+ raise AttributeError("Non-zero extension %s for exact position."
+ % extension)
+ AbstractPosition.__init__(self, position, 0)
+
+ def __repr__(self) :
+ """A string representation of the location for debugging."""
+ assert self.extension == 0
+ return "%s(%s)" % (self.__class__, repr(self.position))
+
+ def __str__(self):
+ return ">%s" % self.position
+
+class OneOfPosition(AbstractPosition):
+ """Specify a position where the location can be multiple positions.
+
+ This models the GenBank 'one-of(1888,1901)' function, and tries
+ to make this fit within the Biopython Position models. In our case
+ the position of the "one-of" is set as the lowest choice, and the
+ extension is the range to the highest choice.
+ """
+ def __init__(self, position_list):
+ """Initialize with a set of posssible positions.
+
+ position_list is a list of AbstractPosition derived objects,
+ specifying possible locations.
+ """
+ # unique attribute for this type of positions
+ self.position_choices = position_list
+ # find the smallest and largest position in the choices
+ smallest = None
+ largest = None
+ for position_choice in self.position_choices:
+ assert isinstance(position_choice, AbstractPosition), \
+ "Expected position objects, got %r" % position_choice
+ if smallest is None and largest is None:
+ smallest = position_choice.position
+ largest = position_choice.position
+ elif position_choice.position > largest:
+ largest = position_choice.position
+ elif position_choice.position < smallest:
+ smallest = position_choice.position
+ # initialize with our definition of position and extension
+ AbstractPosition.__init__(self, smallest, largest - smallest)
+
+ def __repr__(self) :
+ """String representation of the OneOfPosition location for debugging."""
+ return "%s(%s)" % (self.__class__, repr(self.position_choices))
+
+ def __str__(self):
+ out = "one-of("
+ for position in self.position_choices:
+ out += "%s," % position
+ # replace the last comma with the closing parenthesis
+ out = out[:-1] + ")"
+ return out
+
+class PositionGap:
+ """Simple class to hold information about a gap between positions.
+ """
+ def __init__(self, gap_size):
+ """Intialize with a position object containing the gap information.
+ """
+ self.gap_size = gap_size
+
+ def __repr__(self) :
+ """A string representation of the position gap for debugging."""
+ return "%s(%s)" % (self.__class__, repr(self.gap_size))
+
+ def __str__(self):
+ out = "gap(%s)" % self.gap_size
+ return out
git://source.jalview.org / jabaws.git / blobdiff