Changeset 624:4e49e75880be

Timestamp:

09/27/07 10:10:16 (1 year ago)

Author:

Greg Von Kuster <greg@bx.psu.edu>

branch:

default

convert_revision:

svn:9bcadc22-80f8-0310-8a53-c8f022958886/galaxy/trunk@1963

Message:

Streamlined interface for supporting new data types - requires db change and note config change.
db change:
update dataset set extension = 'txt' where extension = 'text';

Adding support for a new data type is now as simple as adding the new type to the config file and optionally adding the
type into the new sniff_order section in the config file, and adding the new class for the data type to the appropriate
datatypes code.

The config file now has a new section [galaxy:sniff_order] which lists the order in which datatype class sniff functions will
be called (each datatype class can now optionally include its own sniff function, although not a requirement).

Support for the 'text' file extension has been eliminated as we will standardize on the 'txt' file extension for the Text data type.

Files:

• lib/galaxy/app.py (modified) (1 diff)
• lib/galaxy/config.py (modified) (1 diff)
• lib/galaxy/datatypes/data.py (modified) (1 diff)
• lib/galaxy/datatypes/images.py (modified) (4 diffs)
• lib/galaxy/datatypes/interval.py (modified) (9 diffs)
• lib/galaxy/datatypes/registry.py (modified) (6 diffs)
• lib/galaxy/datatypes/sequence.py (modified) (5 diffs)
• lib/galaxy/datatypes/sniff.py (modified) (3 diffs)
• lib/galaxy/datatypes/tabular.py (modified) (5 diffs)
• lib/galaxy/datatypes/test/test.gff (modified) (1 diff)
• universe_wsgi.ini.sample (modified) (3 diffs)

lib/galaxy/app.py

@@ -15 +15 @@
-        config.configure_logging( self.config )
-        #Set up datatypes registry
- = self.config.datatypes
+=self.config.datatypes, sniff_order=self.config.sniff_order
-        galaxy.model.set_datatypes_registry(self.datatypes_registry)
-        # Connect up the object model

lib/galaxy/config.py

@@ -61 +61 @@
-        except ConfigParser.NoSectionError:
-            self.datatypes = []
+        #Store sniff order config
+        try:
+            self.sniff_order = global_conf_parser.items("galaxy:sniff_order")
+        except ConfigParser.NoSectionError:
+            self.sniff_order = []
-        self.datatype_converters_config = kwargs.get( 'datatype_converters_config_file', "datatype_converters_conf.xml" )
-        self.datatype_converters_path = kwargs.get( 'datatype_converters_path', os.path.join(self.root,"lib/galaxy/datatypes/converters") )

lib/galaxy/datatypes/data.py

@@ -3 +3 @@
-from cgi import escape
-from galaxy.datatypes.metadata import *
-log = logging.getLogger(__name__)
-from galaxy.datatypes.metadata import MetadataElement
-from galaxy.datatypes import metadata
+
+log = logging.getLogger(__name__)
+
+# Valid strand column values
+valid_strand = ['+', '-', '.']
-
-# Constants for data states

lib/galaxy/datatypes/images.py

@@ -5 +5 @@
-import data
-import logging
+from galaxy.datatypes.sniff import *
-from urllib import urlencode
-
@@ -18 +19 @@
-class Gmaj( data.Data ):
-    """Class describing a GMAJ Applet"""
+    file_ext = "gmaj.zip"
+
-    def set_peek( self, dataset ):
-        dataset.peek  = "<p align=\"center\"><applet code=\"edu.psu.bx.gmaj.MajApplet.class\" archive=\"/static/gmaj/gmaj.jar\" width=\"200\" height=\"30\" align=\"middle\"> <param name=bundle value=\"display?id="+str(dataset.id)+"&tofile=yes&toext=.zip\"> <param name=buttonlabel value=\"Launch GMAJ\"><param name=nobutton value=\"false\"><param name=urlpause value=\"100\"><param name=debug value=\"false\"><i>Your browser is not responding to the &lt;applet&gt; tag.</i></applet></p>"
@@ -30 +33 @@
-        """Returns the mime type of the datatype"""
-        return 'application/zip'
+    def sniff( self, filename ):
+        #TODO: fix me
+        return ''
-
-
-class Laj( data.Text ):
-    """Class describing a LAJ Applet"""
-    def set_peek( self, dataset ):
-        export_url = "/history_add_to?"+urlencode({'history_id':dataset.history_id,'ext':'lav','name':'LAJ Output','info':'Added by LAJ','dbkey':dataset.dbkey})
-        dataset.peek  = "<p align=\"center\"><applet code=\"edu.psu.cse.bio.laj.LajApplet.class\" archive=\"static/laj/laj.jar\" width=\"200\" height=\"30\"><param name=buttonlabel value=\"Launch LAJ\"><param name=title value=\"LAJ in Galaxy\"><param name=posturl value=\""+export_url+"\"><param name=alignfile1 value=\"display?id="+str(dataset.id)+"\"><param name=noseq value=\"true\"></applet></p>"
-        dataset.blurb = 'LAJ Multiple Alignment Viewer'
-        
-    def display_peek(self, dataset):
-        try:
-            return dataset.peek
-        except:
-            return "peek unavailable"
-            
-class Html( data.Text ):
-    """Class describing an html file"""
+    file_ext = "html"
+
-    def set_peek( self, dataset ):
-        dataset.peek  = "HTML file (%s)" % ( data.nice_size( dataset.get_size() ) )
@@ -54 +48 @@
-        """Returns the mime type of the datatype"""
-        return 'text/html'
+
+    def sniff( self, filename ):
+        """
+        Determines wether the file is in html format
+
+        >>> fname = get_test_fname( 'complete.bed' )
+        >>> Html().sniff( fname )
+        ''
+        >>> fname = get_test_fname( 'file.html' )
+        >>> Html().sniff( fname )
+        'html'
+        """
+        headers = get_headers( filename, None )
+
+        try:
+            for i, hdr in enumerate(headers):
+                if hdr and hdr[0].lower().find( '<html>' ) >=0:
+                    return self.file_ext
+            return ''
+        except:
+            return ''
+
+class Laj( data.Text ):
+    """Class describing a LAJ Applet"""
+    file_ext = "laj"
+
+    def set_peek( self, dataset ):
+        export_url = "/history_add_to?"+urlencode({'history_id':dataset.history_id,'ext':'lav','name':'LAJ Output','info':'Added by LAJ','dbkey':dataset.dbkey})
+        dataset.peek  = "<p align=\"center\"><applet code=\"edu.psu.cse.bio.laj.LajApplet.class\" archive=\"static/laj/laj.jar\" width=\"200\" height=\"30\"><param name=buttonlabel value=\"Launch LAJ\"><param name=title value=\"LAJ in Galaxy\"><param name=posturl value=\""+export_url+"\"><param name=alignfile1 value=\"display?id="+str(dataset.id)+"\"><param name=noseq value=\"true\"></applet></p>"
+        dataset.blurb = 'LAJ Multiple Alignment Viewer'
+    def display_peek(self, dataset):
+        try:
+            return dataset.peek
+        except:
+            return "peek unavailable"
+    def sniff( self, filename ):
+        #TODO: fix me...
+        return ''
+

lib/galaxy/datatypes/interval.py

@@ -9 +9 @@
-import data
-from galaxy import util
+from galaxy.datatypes.sniff import *
-from cgi import escape
-import urllib
@@ -37 +38 @@
-class Interval( Tabular ):
-    """Tab delimited data containing interval information"""
+    file_ext = "interval"
-
-    """Add metadata elements"""
@@ -44 +46 @@
-    MetadataElement( name="strandCol", desc="Strand column (click box & select)", param=metadata.ColumnParameter, optional=True, no_value=0 )
-    MetadataElement( name="columns", default=3, desc="Number of columns", readonly=True, visible=False )
-
-
-    def __init__(self, **kwd):
@@ -180 +181 @@
-        return [("lines","Remove erroneous lines")]
-
+    def sniff( self, filename ):
+        """
+        Checks for 'intervalness'
+    
+        This format is mostly used by galaxy itself.  Valid interval files should include
+        a valid header comment, but this seems to be loosely regulated.
+        
+        >>> fname = get_test_fname( 'test_space.bed' )
+        >>> Interval().sniff( fname )
+        ''
+        >>> fname = get_test_fname( 'interval.interval' )
+        >>> Interval().sniff( fname )
+        'interval'
+        """
+        headers = get_headers( filename, '\t' )   
+        try:
+            """
+            If we got here, we already know the file is_column_based and is not bed,
+            so we'll just look for some valid data.
+            """
+            for hdr in headers:
+                if not (hdr[0] == '' or hdr[0].startswith( '#' )):
+                    if len(hdr) < 3:
+                        return ''
+                    try:
+                        map( int, [hdr[1], hdr[2]] )
+                    except:
+                        return ''
+            return self.file_ext
+        except:
+            return ''
+    
-class Bed( Interval ):
-    """Tab delimited data in BED format"""
+    file_ext = "bed"
-
-    """Add metadata elements"""
@@ -265 +299 @@
-        except: return "This item contains no content"
-
+    def sniff( self, filename ):
+        """
+        Checks for 'bedness'
+        
+        BED lines have three required fields and nine additional optional fields. 
+        The number of fields per line must be consistent throughout any single set of data in 
+        an annotation track.
+        
+        For complete details see http://genome.ucsc.edu/FAQ/FAQformat#format1
+        
+        >>> fname = get_test_fname( 'test_tab.bed' )
+        >>> Bed().sniff( fname )
+        'bed'
+        >>> fname = get_test_fname( 'interval.bed' )
+        >>> Bed().sniff( fname )
+        ''
+        >>> fname = get_test_fname( 'complete.bed' )
+        >>> Bed().sniff( fname )
+        'bed'
+        """
+        col1_startswith = ['chr', 'chl', 'groupun', 'reftig_', 'scaffold', 'super_', 'vcho']
+        headers = get_headers( filename, '\t' )
+        try:
+            if not headers:
+                return ''
+            for hdr in headers:
+                valid_col1 = False
+                if len(hdr) < 3 or len(hdr) > 12:
+                    return ''
+                for str in col1_startswith:
+                    if hdr[0].lower().startswith(str):
+                        valid_col1 = True
+                        break
+                if valid_col1:
+                    try:
+                        map( int, [hdr[1], hdr[2]] )
+                    except:
+                        return ''
+                    if len(hdr) > 3:
+                        """
+                        Since all 9 of these fields are optional, it is difficult to test
+                        for specific column values...
+                        """
+                        optionals = hdr[3:]
+                        """
+                        ...we can, however, test complete BED definitions fairly easily.
+                        """
+                        if len(optionals) == 9:
+                            try:
+                                map ( int, [optionals[1], optionals[3], optionals[4], optionals[5], optionals[6]] )
+                            except:
+                                return ''
+                            score = int(optionals[1])
+                            if score < 0 or score > 1000:
+                                return ''
+                            if optionals[2] not in ['+', '-']:
+                                return ''
+                            if int(optionals[5]) != 0:
+                                return ''
+                            block_count = int(optionals[6])
+                            """
+                            Sometimes the blosck_sizes and block_starts lists end in extra commas
+                            """
+                            block_sizes = optionals[7].rstrip(',').split(',')
+                            block_starts = optionals[8].rstrip(',').split(',')
+                            if len(block_sizes) != block_count or len(block_starts) != block_count:
+                                return ''
+                        elif len(optionals) > 4 and len(optionals) < 9:
+                            """
+                            Here it gets a bit trickier, but in this case, we can be somewhat confident 
+                            that optionals will include a strand column
+                            """
+                            is_valid_strand = False
+                            for ele in optionals:
+                                if ele in data.valid_strand:
+                                    is_valid_strand = True
+                            if not is_valid_strand:
+                                return ''
+                else:
+                    return ''
+            return self.file_ext
+        except:
+            return ''
+
-class Gff( Tabular ):
-    """Tab delimited data in Gff format"""
+    file_ext = "gff"
-
-    """Add metadata elements"""
@@ -331 +450 @@
-        return ret_val
-
+    def sniff( self, filename ):
+        """
+        Determines whether the file is in gff format
+        
+        GFF lines have nine required fields that must be tab-separated.
+        
+        For complete details see http://genome.ucsc.edu/FAQ/FAQformat#format3
+        
+        >>> fname = get_test_fname( 'gff_version_3.gff' )
+        >>> Gff().sniff( fname )
+        ''
+        >>> fname = get_test_fname( 'test.gff' )
+        >>> Gff().sniff( fname )
+        'gff'
+        """
+        headers = get_headers( filename, '\t' )
+        try:
+            if len(headers) < 2:
+                return ''
+            for hdr in headers:
+                if hdr and hdr[0].startswith( '##gff-version' ) and hdr[0].find( '2' ) < 0:
+                    return ''
+                if hdr and hdr[0] and not hdr[0].startswith( '#' ):
+                    if len(hdr) != 9:
+                        return ''
+                    try:
+                        map( int, [hdr[3], hdr[4]] )
+                    except:
+                        return ''
+                    if hdr[5] != '.':
+                        try:
+                            score = int(hdr[5])
+                        except:
+                            return ''
+                        if (score < 0 or score > 1000):
+                            return ''
+                    if hdr[6] not in data.valid_strand:
+                        return ''
+            return self.file_ext
+        except:
+            return ''
+
-class Gff3( Gff ):
-    """Tab delimited data in Gff3 format"""
+    file_ext = "gff3"
-
-    """Add metadata elements"""
@@ -341 +503 @@
-        Gff.__init__(self, **kwd)
-
+    def sniff( self, filename ):
+        """
+        Determines whether the file is in gff version 3 format
+        
+        GFF 3 format:
+    
+        1) adds a mechanism for representing more than one level 
+           of hierarchical grouping of features and subfeatures.
+        2) separates the ideas of group membership and feature name/id
+        3) constrains the feature type field to be taken from a controlled
+           vocabulary.
+        4) allows a single feature, such as an exon, to belong to more than
+           one group at a time.
+        5) provides an explicit convention for pairwise alignments
+        6) provides an explicit convention for features that occupy disjunct regions
+        
+        The format consists of 9 columns, separated by tabs (NOT spaces).
+        
+        Undefined fields are replaced with the "." character, as described in the original GFF spec.
+    
+        For complete details see http://song.sourceforge.net/gff3.shtml
+        
+        >>> fname = get_test_fname( 'test.gff' )
+        >>> Gff3().sniff( fname )
+        ''
+        >>> fname = get_test_fname('gff_version_3.gff')
+        >>> Gff3().sniff( fname )
+        'gff3'
+        """
+        valid_gff3_strand = ['+', '-', '.', '?']
+        valid_gff3_phase = ['.', '0', '1', '2']
+        headers = get_headers( filename, '\t' )
+        try:
+            if len(headers) < 2:
+                return ''
+            for hdr in headers:
+                if hdr and hdr[0].startswith( '##gff-version' ) and hdr[0].find( '3' ) < 0:
+                    return ''
+                if hdr and hdr[0] and not hdr[0].startswith( '#' ):
+                    if len(hdr) != 9: 
+                        return ''
+                    try:
+                        map( int, [hdr[3]] )
+                    except:
+                        if hdr[3] != '.':
+                            return ''
+                    try:
+                        map( int, [hdr[4]] )
+                    except:
+                        if hdr[4] != '.':
+                            return ''
+                    if hdr[5] != '.':
+                        try:
+                            score = int(hdr[5])
+                        except:
+                            return ''
+                        if (score < 0 or score > 1000):
+                            return ''
+                    if hdr[6] not in valid_gff3_strand:
+                        return ''
+                    if hdr[7] not in valid_gff3_phase:
+                        return ''
+            return self.file_ext
+        except:
+            return ''
+
-class Wiggle( Tabular ):
-    """Tab delimited data in wiggle format"""
+    file_ext = "wig"
+
-    MetadataElement( name="columns", default=3, desc="Number of columns", readonly=True )
-    
-    def make_html_table(self, data):
-        return Tabular.make_html_table(self, data, skipchar='#')
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-class CustomTrack ( Tabular ):
-    """UCSC CustomTrack"""
-
+
+
-    def __init__(self, **kwd):
-        """Initialize interval datatype, by adding UCSC display app"""
@@ -395 +655 @@
-        return ret_val
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-class GBrowseTrack ( Tabular ):
+    """GMOD GBrowseTrack"""
+    file_ext = "gbrowsetrack"
-
-    def __init__(self, **kwd):
@@ -432 +732 @@
-        return open(dataset.file_name)
-
+    def sniff( self, filename ):
+        """
+        Determines whether the file is in gbrowsetrack format.
+        
+        GBrowseTrack files are built within Galaxy.
+        TODO: Not yet sure what this file will look like.  Fix this sniffer and add some unit tests here as soon as we know.
+        """
+        return ''
+
-if __name__ == '__main__':
-    import doctest, sys

lib/galaxy/datatypes/registry.py

@@ -9 +9 @@
-
-class Registry( object ):
- = 
+=[], sniff_order=
-        self.log = logging.getLogger(__name__)
-        self.datatypes_by_extension = {}
-        self.mimetypes_by_extension = {}
-        self.datatype_converters = odict()
+        self.sniff_order = []
-        for ext, kind in datatypes:
-            try:
@@ -39 +40 @@
-                'data'     : data.Data(), 
-                'bed'      : interval.Bed(), 
-
-
+
-                'interval' : interval.Interval(), 
-                'tabular'  : tabular.Tabular(),
@@ -55 +55 @@
-                'lav'      : sequence.Lav(),
-                'html'     : images.Html(),
-
-
+
-            }
-            self.mimetypes_by_extension = { 
-                'data'     : 'application/octet-stream', 
-                'bed'      : 'text/plain', 
-
-
+
-                'interval' : 'text/plain', 
-                'tabular'  : 'text/plain',
@@ -77 +75 @@
-                'lav'      : 'text/plain',
-                'html'     : 'text/html',
-
-
+
-            }
+        """
+        The order in which we attempt to determine data types is critical
+        because some formats are much more flexibly defined than others.
+        """
+        sniff_order.sort()
+        for ord, kind in sniff_order:
+            try:
+                fields = kind.split(":")
+                datatype_module = fields[0]
+                datatype_class = fields[1]
+                fields = datatype_module.split(".")
+                module = __import__(fields.pop(0))
+                for mod in fields: module = getattr(module,mod)
+                aclass = getattr(module, datatype_class)() 
+                included = False
+                for atype in self.sniff_order:
+                    if isinstance(atype, aclass.__class__):
+                        included = True
+                        break
+                if not included:
+                    self.sniff_order.append(aclass)
+            except Exception, exc:
+                self.log.warning('error appending datatype: %s to sniff_order, error: %s' %(str(kind), str(exc)))
+        #default values
+        if len(self.sniff_order) < 1:
+            self.sniff_order = [
+                images.Gmaj(),
+                images.Laj(),
+                sequence.Maf(),
+                sequence.Lav(),
+                sequence.Fasta(),
+                interval.Wiggle(),
+                images.Html(),
+                sequence.Axt(),
+                interval.Bed(), 
+                interval.CustomTrack(),
+                interval.Gff(),
+                interval.Gff3(),
+                interval.Interval()
+            ]
+        def append_to_sniff_order():
+            """Just in case any supported data types are not included in the config's sniff_order section."""
+            for ext in self.datatypes_by_extension:
+                datatype = self.datatypes_by_extension[ext]
+                included = False
+                for atype in self.sniff_order:
+                    if isinstance(atype, datatype.__class__):
+                        included = True
+                        break
+                if not included:
+                    self.sniff_order.append(datatype)
+        append_to_sniff_order()
-    
-    def get_mimetype_by_extension(self, ext ):
-
-
-
+
-        try:
-            mimetype = self.mimetypes_by_extension[ext]
@@ -94 +141 @@
-    
-    def get_datatype_by_extension(self, ext ):
-
-
-
+
-        try:
-            builder = self.datatypes_by_extension[ext]
@@ -115 +160 @@
-
-    def old_change_datatype(self, data, ext):
-
-
-
+
-        newdata = factory(ext)(id=data.id)
-        for key, value in data.__dict__.items():

lib/galaxy/datatypes/sequence.py

@@ -8 +8 @@
-from galaxy.datatypes import metadata
-from galaxy import util
+from sniff import *
-
-log = logging.getLogger(__name__)
@@ -23 +24 @@
-class Fasta( Sequence ):
-    """Class representing a FASTA sequence"""
+    file_ext = "fasta"
-
-    def set_peek( self, dataset ):
@@ -38 +40 @@
-            dataset.blurb = '%d sequences' % count
-
+    def sniff(self, filename):
+        """
+        Determines whether the file is in fasta format
+        
+        A sequence in FASTA format consists of a single-line description, followed by lines of sequence data. 
+        The first character of the description line is a greater-than (">") symbol in the first column. 
+        All lines should be shorter than 80 charcters
+        
+        For complete details see http://www.g2l.bio.uni-goettingen.de/blast/fastades.html
+        
+        >>> fname = get_test_fname( 'sequence.maf' )
+        >>> Fasta().sniff( fname )
+        ''
+        >>> fname = get_test_fname( 'sequence.fasta' )
+        >>> Fasta().sniff( fname )
+        'fasta'
+        """
+        headers = get_headers( filename, None )
+        try:
+            if len(headers) > 1 and headers[0][0] and headers[0][0][0] == ">":
+                return self.file_ext
+            else:
+                return ''
+        except:
+            return ''
+
-try:
-    import pkg_resources; pkg_resources.require( "bx-python" )
@@ -43 +71 @@
-except:
-    pass
+
-class Maf( Alignment ):
-    """Class describing a Maf alignment"""
-
+
+
-    def init_meta( self, dataset, copy_from=None ):
-        Alignment.init_meta( self, dataset, copy_from=copy_from )
@@ -78 +108 @@
-        return False
-
+    def sniff( self, filename ):
+        """
+        Determines wether the file is in maf format
+        
+        The .maf format is line-oriented. Each multiple alignment ends with a blank line. 
+        Each sequence in an alignment is on a single line, which can get quite long, but 
+        there is no length limit. Words in a line are delimited by any white space. 
+        Lines starting with # are considered to be comments. Lines starting with ## can 
+        be ignored by most programs, but contain meta-data of one form or another.
+        
+        The first line of a .maf file begins with ##maf. This word is followed by white-space-separated 
+        variable=value pairs. There should be no white space surrounding the "=".
+     
+        For complete details see http://genome.ucsc.edu/FAQ/FAQformat#format5
+        
+        >>> fname = get_test_fname( 'sequence.maf' )
+        >>> Maf().sniff( fname )
+        'maf'
+        >>> fname = get_test_fname( 'sequence.fasta' )
+        >>> Maf().sniff( fname )
+        ''
+        """
+        headers = get_headers( filename, None )
+        try:
+            if len(headers) > 1 and headers[0][0] and headers[0][0] == "##maf":
+                return self.file_ext
+            else:
+                return ''
+        except:
+            return ''
+
-class Axt( Alignment ):
-    """Class describing an axt alignment"""
+    file_ext = "axt"
+
+    def sniff( self, filename ):
+        """
+        Determines whether the file is in axt format
+        
+        axt alignment files are produced from Blastz, an alignment tool available from Webb Miller's lab 
+        at Penn State University.  Each alignment block in an axt file contains three lines: a summary 
+        line and 2 sequence lines. Blocks are separated from one another by blank lines.
+        
+        The summary line contains chromosomal position and size information about the alignment. It consists of 9 required fields:
+    
+        For complete details see http://genome.ucsc.edu/goldenPath/help/axt.html
+        
+        >>> fname = get_test_fname( 'alignment.axt' )
+        >>> Axt().sniff( fname )
+        'axt'
+        >>> fname = get_test_fname( 'alignment.lav' )
+        >>> Axt().sniff( fname )
+        ''
+       """
+        headers = get_headers( filename, None )
+        if len(headers) < 4:
+            return ''
+        try:
+            """Assume the summary line is the first line of the file."""   
+            line = headers[0]
+        except:
+            return ''
+ 
+        if len(line) != 9:
+            return ''
+        try:
+            map ( int, [line[0], line[2], line[3], line[5], line[6], line[8]] )
+        except:
+            return ''
+        if line[7] not in data.valid_strand:
+            return ''
+        return self.file_ext
-
-class Lav( Alignment ):
-    """Class describing a LAV alignment"""
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

lib/galaxy/datatypes/sniff.py

@@ -3 +3 @@
-"""
-import logging, sys, os, csv, tempfile, shutil, re
+import registry
-
-log = logging.getLogger(__name__)
-
-valid_strand = ['+', '-', '.']
-valid_gff3_strand = ['+', '-', '.', '?']
-valid_gff3_phase = ['.', '0', '1', '2']
-        
-def get_test_fname(fname):
@@ -116 +113 @@
-    if not headers:
-        return False
-    
-    for hdr in headers[skip:]:
-        if len(hdr) > 1 and hdr[0] and not hdr[0].startswith('#'):
-            count = len(hdr)
-            break
-    
-    if count < 2:
-        return False
-    
-    for hdr in headers[skip:]:
-        if len(hdr) > 1 and hdr[0] and not hdr[0].startswith('#') and len(hdr) != count:
-            return False
-    return True
-        
-def is_fasta(headers):
-    """
-    Determines wether the file is in fasta format
-    
-    A sequence in FASTA format consists of a single-line description, followed by lines of sequence data. 
-    The first character of the description line is a greater-than (">") symbol in the first column. 
-    All lines should be shorter than 80 charcters
-    
-    For complete details see http://www.g2l.bio.uni-goettingen.de/blast/fastades.html
-    
-    >>> headers = get_headers(__file__, ' ')
-    >>> is_fasta(headers)
-    False
-    >>> fname = get_test_fname('sequence.fasta')
-    >>> headers = get_headers(fname,' ')
-    >>> is_fasta(headers)
-    True
-    """
-    try:
-        return len(headers) > 1 and headers[0][0] and headers[0][0][0] == ">"
-    except:
-        return False
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-