--- /dev/null
+# Copyright 2006-2008 by Peter Cock. All rights reserved.
+# This code is part of the Biopython distribution and governed by its
+# license. Please see the LICENSE file that should have been included
+# as part of this package.
+"""
+Bio.SeqIO support module (not for general use).
+
+Unless you are writing a new parser or writer for Bio.SeqIO, you should not
+use this module. It provides base classes to try and simplify things.
+"""
+
+from Bio.Alphabet import generic_alphabet
+
+class SequenceIterator :
+ """Base class for building SeqRecord iterators.
+
+ You should write a next() method to return SeqRecord
+ objects. You may wish to redefine the __init__
+ method as well.
+ """
+ def __init__(self, handle, alphabet=generic_alphabet) :
+ """Create a SequenceIterator object.
+
+ handle - input file
+ alphabet - optional, e.g. Bio.Alphabet.generic_protein
+
+ Note when subclassing:
+ - there should be a single non-optional argument,
+ the handle.
+ - you do not have to require an alphabet.
+ - you can add additional optional arguments."""
+ self.handle = handle
+ self.alphabet = alphabet
+ #####################################################
+ # You may want to subclass this, for example #
+ # to read through the file to find the first record,#
+ # or if additional arguments are required. #
+ #####################################################
+
+ def next(self) :
+ """Return the next record in the file.
+
+ This method should be replaced by any derived class to do something useful."""
+ raise NotImplementedError("This object should be subclassed")
+ #####################################################
+ # You SHOULD subclass this, to split the file up #
+ # into your individual records, and convert these #
+ # into useful objects, e.g. return SeqRecord object #
+ #####################################################
+
+ def __iter__(self):
+ """Iterate over the entries as a SeqRecord objects.
+
+ Example usage for Fasta files:
+
+ myFile = open("example.fasta","r")
+ myFastaReader = FastaIterator(myFile)
+ for record in myFastaReader :
+ print record.id
+ print record.seq
+ myFile.close()"""
+ return iter(self.next, None)
+
+class InterlacedSequenceIterator(SequenceIterator) :
+ """Base class for any iterator of a non-sequential file type.
+
+ This object is not intended for use directly.
+
+ When writing a parser for any interlaced sequence file where the whole
+ file must be read in order to extract any single record, then you should
+ subclass this object.
+
+ All you need to do is to define your own:
+ (1) __init__ method to parse the file and call self.move_start()
+ (2) __len__ method to return the number of records
+ (3) __getitem__ to return any requested record.
+
+ This class will then provide the iterator methods including next(), but relies
+ on knowing the total number of records and tracking the pending record index in
+ as self._n
+
+ It is up to the subclassed object to decide if it wants to generate a cache of
+ SeqRecords when initialised, or simply use its own lists and dicts and create
+ SeqRecords on request.
+ """
+
+ def __init__(self) :
+ """Create the object.
+
+ This method should be replaced by any derived class to do something useful."""
+ #We assume that your implementation of __init__ will ensure self._n=0
+ self.move_start()
+ raise NotImplementedError("This object method should be subclassed")
+ #####################################################
+ # You SHOULD subclass this #
+ #####################################################
+
+ def __len__(self) :
+ """Return the number of records.
+
+ This method should be replaced by any derived class to do something useful."""
+ raise NotImplementedError("This object method should be subclassed")
+ #####################################################
+ # You SHOULD subclass this #
+ #####################################################
+
+ def __getitem__(self, i) :
+ """Return the requested record.
+
+ This method should be replaced by any derived class to do something
+ useful.
+
+ It should NOT touch the value of self._n"""
+ raise NotImplementedError("This object method should be subclassed")
+ #####################################################
+ # You SHOULD subclass this #
+ #####################################################
+
+ def move_start(self) :
+ self._n = 0
+
+ def next(self) :
+ next_record = self._n
+ if next_record < len(self) :
+ self._n = next_record+1
+ return self[next_record]
+ else :
+ #StopIteration
+ return None
+
+ def __iter__(self):
+ return iter(self.next, None)
+
+class SequenceWriter:
+ """This class should be subclassed.
+
+ Interlaced file formats (e.g. Clustal) should subclass directly.
+
+ Sequential file formats (e.g. Fasta, GenBank) should subclass
+ the SequentialSequenceWriter class instead.
+ """
+ def __init__(self, handle):
+ """Creates the writer object.
+
+ Use the method write_file() to actually record your sequence records."""
+ self.handle = handle
+
+ def _get_seq_string(self, record):
+ """Use this to catch errors like the sequence being None."""
+ try :
+ #The tostring() method is part of the Seq API, we could instead
+ #use str(record.seq) but that would give a string "None" if the
+ #sequence was None, and unpredicatable output if an unexpected
+ #object was present.
+ return record.seq.tostring()
+ except AttributeError :
+ if record.seq is None :
+ #We could silently treat this as an empty sequence, Seq(""),
+ #but that would be an implict assumption we should avoid.
+ raise TypeError("SeqRecord (id=%s) has None for its sequence." \
+ % record.id)
+ else :
+ raise TypeError("SeqRecord (id=%s) has an invalid sequence." \
+ % record.id)
+
+ def clean(self, text) :
+ """Use this to avoid getting newlines in the output."""
+ answer = text
+ for x in ["\n", "\r"] :
+ answer = answer.replace(x, " ")
+ return answer.replace(" ", " ")
+
+ def write_file(self, records) :
+ """Use this to write an entire file containing the given records.
+
+ records - A list or iterator returning SeqRecord objects
+
+ Should return the number of records (as an integer).
+
+ This method can only be called once."""
+ #Note when implementing this, you should close the file at the end.
+ raise NotImplementedError("This object should be subclassed")
+ #####################################################
+ # You SHOULD subclass this #
+ #####################################################
+
+class SequentialSequenceWriter(SequenceWriter):
+ """This class should be subclassed.
+
+ It is intended for sequential file formats with an (optional)
+ header, repeated records, and an (optional) footer.
+
+ In this case (as with interlaced file formats), the user may
+ simply call the write_file() method and be done.
+
+ However, they may also call the write_header(), followed
+ by multiple calls to write_record() and/or write_records()
+ followed finally by write_footer().
+
+ Users must call write_header() and write_footer() even when
+ the file format concerned doesn't have a header or footer.
+ This is to try and make life as easy as possible when
+ switching the output format.
+
+ Note that write_header() cannot require any assumptions about
+ the number of records.
+ """
+ def __init__(self, handle):
+ self.handle = handle
+ self._header_written = False
+ self._record_written = False
+ self._footer_written = False
+
+ def write_header(self) :
+ assert not self._header_written, "You have aleady called write_header()"
+ assert not self._record_written, "You have aleady called write_record() or write_records()"
+ assert not self._footer_written, "You have aleady called write_footer()"
+ self._header_written = True
+
+ def write_footer(self) :
+ assert self._header_written, "You must call write_header() first"
+ assert self._record_written, "You have not called write_record() or write_records() yet"
+ assert not self._footer_written, "You have aleady called write_footer()"
+ self._footer_written = True
+
+ def write_record(self, record):
+ """Write a single record to the output file.
+
+ record - a SeqRecord object
+
+ Once you have called write_header() you can call write_record()
+ and/or write_records() as many times as needed. Then call
+ write_footer() and close()."""
+ assert self._header_written, "You must call write_header() first"
+ assert not self._footer_written, "You have already called write_footer()"
+ self._record_written = True
+ raise NotImplementedError("This object should be subclassed")
+ #####################################################
+ # You SHOULD subclass this #
+ #####################################################
+
+ def write_records(self, records):
+ """Write multiple record to the output file.
+
+ records - A list or iterator returning SeqRecord objects
+
+ Once you have called write_header() you can call write_record()
+ and/or write_records() as many times as needed. Then call
+ write_footer() and close().
+
+ Returns the number of records written.
+ """
+ #Default implementation:
+ assert self._header_written, "You must call write_header() first"
+ assert not self._footer_written, "You have already called write_footer()"
+ count = 0
+ for record in records :
+ self.write_record(record)
+ count += 1
+ #Mark as true, even if there where no records
+ self._record_written = True
+ return count
+
+ def write_file(self, records) :
+ """Use this to write an entire file containing the given records.
+
+ records - A list or iterator returning SeqRecord objects
+
+ This method can only be called once. Returns the number of records
+ written.
+ """
+ self.write_header()
+ count = self.write_records(records)
+ self.write_footer()
+ return count
git://source.jalview.org / jabaws.git / blobdiff