Changeset 1371:b772c96abe5e

Show
Ignore:
Timestamp:
06/09/08 11:20:42 (7 months ago)
Author:
Greg Von Kuster <greg@bx.psu.edu>
branch:
default
convert_revision:
svn:9bcadc22-80f8-0310-8a53-c8f022958886/galaxy/trunk@2732
Message:

Requires Galaxy config change - merged former Galaxy config [datatypes] and [sniff order] sections, along with former datatype_converters.xml into 1 xml file, datatypes_conf.xml.
The new datatypes_conf.xml.sample should be copied to datatypes_conf.xml.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • lib/galaxy/app.py

    r1186 r1371  
    1414        self.config.check() 
    1515        config.configure_logging( self.config ) 
    16         #Set up datatypes registry 
    17         self.datatypes_registry = galaxy.datatypes.registry.Registry(datatypes=self.config.datatypes, sniff_order=self.config.sniff_order) 
    18         galaxy.model.set_datatypes_registry(self.datatypes_registry) 
     16        # Set up datatypes registry 
     17        self.datatypes_registry = galaxy.datatypes.registry.Registry( self.config.root, self.config.datatypes_config ) 
     18        galaxy.model.set_datatypes_registry( self.datatypes_registry ) 
    1919        # Determine the database url 
    2020        if self.config.database_connection: 
    …… 
    3030        self.toolbox = tools.ToolBox( self.config.tool_config, self.config.tool_path, self ) 
    3131        #Load datatype converters 
    32         self.datatypes_registry.load_datatype_converters(self.config.datatype_converters_config, self.config.datatype_converters_path, self.toolbox) 
     32        self.datatypes_registry.load_datatype_converters( self.toolbox ) 
    3333        # Start the job queue 
    3434        job_dispatcher = jobs.DefaultJobDispatcher( self ) 

  • lib/galaxy/config.py

    r1356 r1371  
    7373        except ConfigParser.NoSectionError: 
    7474            self.tool_runners = [] 
    75         #Store datatypes config 
    76         try: 
    77             self.datatypes = global_conf_parser.items("galaxy:datatypes") 
    78         except ConfigParser.NoSectionError: 
    79             self.datatypes = [] 
    80         #Store sniff order config 
    81         try: 
    82             self.sniff_order = global_conf_parser.items("galaxy:sniff_order") 
    83         except ConfigParser.NoSectionError: 
    84             self.sniff_order = [] 
    85         self.datatype_converters_config = kwargs.get( 'datatype_converters_config_file', "datatype_converters_conf.xml" ) 
    86         self.datatype_converters_path = kwargs.get( 'datatype_converters_path', os.path.join(self.root,"lib/galaxy/datatypes/converters") ) 
     75        self.datatypes_config = kwargs.get( 'datatypes_config_file', 'datatypes_conf.xml' ) 
    8776    def get( self, key, default ): 
    8877        return self.config_dict.get( key, default ) 
    8978    def check( self ): 
    9079        # Check that required directories exist 
    91         for path in self.root, self.file_path, self.tool_path, self.tool_data_path, self.template_path, self.job_working_directory, self.datatype_converters_path: 
     80        for path in self.root, self.file_path, self.tool_path, self.tool_data_path, self.template_path, self.job_working_directory: 
    9281            if not os.path.isdir( path ): 
    9382                raise ConfigurationError("Directory does not exist: %s" % path ) 
    9483        # Check that required files exist 
    95         for path in self.tool_config, self.datatype_converters_config: 
     84        for path in self.tool_config, self.datatypes_config: 
    9685            if not os.path.isfile(path): 
    9786                raise ConfigurationError("File not found: %s" % path ) 

  • lib/galaxy/datatypes/registry.py

    r1367 r1371  
    44import os 
    55import logging 
    6 import data, tabular, interval, images, sequence, qualityscore 
    7 import genetics # needed for rgenetics tools     
     6import data, tabular, interval, images, sequence, qualityscore, genetics         
    87import galaxy.util 
    98from galaxy.util.odict import odict 
    109 
     10class ConfigurationError( Exception ): 
     11    pass 
     12 
    1113class Registry( object ): 
    12     def __init__( self, datatypes=[], sniff_order=[] ): 
     14    def __init__( self, root_dir=None, config=None ): 
    1315        self.log = logging.getLogger(__name__) 
    1416        self.datatypes_by_extension = {} 
    1517        self.mimetypes_by_extension = {} 
    1618        self.datatype_converters = odict() 
     19        self.converters = [] 
     20        self.sniff_order = [] 
    1721        self.upload_file_formats = [] 
    18         self.sniff_order = [] 
    19         for ext, kind in datatypes: 
    20             # Data types are defined in the config like this: 
    21             # #<file extension> = <data type class>,<mime type (optional)>,<display in upload select list (optional)> 
    22             try: 
    23                 fields = kind.split(",") 
    24                 kind = fields[0].strip() 
    25                 mime_type = None 
    26                 display_in_upload = False 
    27                 # See if we have a mime type or a display_in_upload 
     22        if root_dir and config: 
     23            # Parse datatypes_conf.xml 
     24            tree = galaxy.util.parse_xml( config ) 
     25            root = tree.getroot() 
     26            # Load datatypes and converters from config 
     27            self.log.debug( 'Loading datatypes from %s' % config ) 
     28            registration = root.find( 'registration' ) 
     29            self.datatype_converters_path = os.path.join( root_dir, registration.get( 'converters_path', 'lib/galaxy/datatypes/converters' ) ) 
     30            if not os.path.isdir( self.datatype_converters_path ): 
     31                raise ConfigurationError( "Directory does not exist: %s" % self.datatype_converters_path ) 
     32            for elem in registration.findall( 'datatype' ): 
    2833                try: 
    29                     ele = fields[1].strip() 
    30                     if ele: 
    31                         if ele == 'display_in_upload': 
    32                             display_in_upload = True 
    33                         else: 
    34                             mime_type = ele 
    35                 except: 
    36                     pass 
    37                 # See if we have a display_in_upload 
    38                 if not display_in_upload: 
    39                     try: 
    40                         ele = fields[2].strip() 
    41                         if ele == 'display_in_upload': 
    42                             display_in_upload = True 
    43                     except: 
    44                         pass 
    45                 if display_in_upload: 
    46                     self.upload_file_formats.append( ext ) 
    47                 fields = kind.split(":") 
    48                 datatype_module = fields[0] 
    49                 datatype_class = fields[1] 
    50                 fields = datatype_module.split(".") 
    51                 module = __import__( fields.pop(0) ) 
    52                 for mod in fields: 
    53                     module = getattr(module,mod) 
    54                 self.datatypes_by_extension[ext] = getattr(module, datatype_class)() 
    55                 if mime_type is None: 
    56                     # Use default mime type as per datatype spec 
    57                     mime_type = self.datatypes_by_extension[ext].get_mime() 
    58                 self.mimetypes_by_extension[ext] = mime_type 
    59             except Exception, e: 
    60                 self.log.warning('error loading datatype "%s", problem: %s' % ( ext, str( e ) ) ) 
     34                    extension = elem.get( 'extension', None )  
     35                    type = elem.get( 'type', None ) 
     36                    mimetype = elem.get( 'mimetype', None ) 
     37                    display_in_upload = elem.get( 'display_in_upload', False ) 
     38                    if extension and type: 
     39                        fields = type.split( ':' ) 
     40                        datatype_module = fields[0] 
     41                        datatype_class = fields[1] 
     42                        fields = datatype_module.split( '.' ) 
     43                        module = __import__( fields.pop(0) ) 
     44                        for mod in fields: 
     45                            module = getattr( module, mod ) 
     46                        self.datatypes_by_extension[extension] = getattr( module, datatype_class )() 
     47                        if mimetype is None: 
     48                            # Use default mime type as per datatype spec 
     49                            mimetype = self.datatypes_by_extension[extension].get_mime() 
     50                        self.mimetypes_by_extension[extension] = mimetype 
     51                        if display_in_upload: 
     52                            self.upload_file_formats.append( extension ) 
     53                        for converter in elem.findall( 'converter' ): 
     54                            # Build the list of datatype converters which will later be loaded  
     55                            # into the calling app's toolbox. 
     56                            converter_config = converter.get( 'file', None ) 
     57                            target_datatype = converter.get( 'target_datatype', None ) 
     58                            if converter_config and target_datatype: 
     59                                self.converters.append( ( converter_config, extension, target_datatype ) ) 
     60                except Exception, e: 
     61                    self.log.warning( 'Error loading datatype "%s", problem: %s' % ( extension, str( e ) ) ) 
     62            # Load datatype sniffers from config 
     63            sniff_order = [] 
     64            sniffers = root.find( 'sniffers' ) 
     65            for elem in sniffers.findall( 'sniffer' ): 
     66                order = elem.get( 'order', None )  
     67                type = elem.get( 'type', None ) 
     68                if order and type: 
     69                    sniff_order.append( ( order, type ) ) 
     70            sniff_order.sort() 
     71            for ele in sniff_order: 
     72                try: 
     73                    type = ele[1] 
     74                    fields = type.split( ":" ) 
     75                    datatype_module = fields[0] 
     76                    datatype_class = fields[1] 
     77                    fields = datatype_module.split( "." ) 
     78                    module = __import__( fields.pop(0) ) 
     79                    for mod in fields: 
     80                        module = getattr( module, mod ) 
     81                    aclass = getattr( module, datatype_class )()  
     82                    included = False 
     83                    for atype in self.sniff_order: 
     84                        if not issubclass( atype.__class__, aclass.__class__ ) and isinstance( atype, aclass.__class__ ): 
     85                            included = True 
     86                            break 
     87                    if not included: 
     88                        self.sniff_order.append( aclass ) 
     89                        self.log.debug( 'Loaded sniffer for datatype: %s' % type ) 
     90                except Exception, exc: 
     91                    self.log.warning( 'Error appending datatype %s to sniff_order, problem: %s' % ( type, str( exc ) ) ) 
    6192        #default values 
    6293        if len(self.datatypes_by_extension) < 1: 
    …… 
    105136                'wig'         : 'text/plain' 
    106137            } 
    107         """ 
    108         The order in which we attempt to determine data types is critical 
    109         because some formats are much more flexibly defined than others. 
    110         """ 
    111         sniff_order.sort() 
    112         for ele in sniff_order: 
    113             try: 
    114                 ord = ele[0] 
    115                 kind = ele[1] 
    116                 fields = kind.split( ":" ) 
    117                 datatype_module = fields[0] 
    118                 datatype_class = fields[1] 
    119                 fields = datatype_module.split( "." ) 
    120                 module = __import__( fields.pop(0) ) 
    121                 for mod in fields: 
    122                     module = getattr( module, mod ) 
    123                 aclass = getattr( module, datatype_class )()  
    124                 included = False 
    125                 for atype in self.sniff_order: 
    126                     if not issubclass( atype.__class__, aclass.__class__ ) and isinstance( atype, aclass.__class__ ): 
    127                         included = True 
    128                         break 
    129                 if not included: 
    130                     self.sniff_order.append( aclass ) 
    131             except Exception, exc: 
    132                 self.log.warning( 'error appending datatype: %s to sniff_order, error: %s' % ( str( kind ), str( exc ) ) ) 
    133         #default values 
     138        # Default values - the order in which we attempt to determine data types is critical 
     139        # because some formats are much more flexibly defined than others. 
    134140        if len(self.sniff_order) < 1: 
    135141            self.sniff_order = [ 
    …… 
    147153            ] 
    148154        def append_to_sniff_order(): 
    149             """Just in case any supported data types are not included in the config's sniff_order section.""" 
     155            # Just in case any supported data types are not included in the config's sniff_order section. 
    150156            for ext in self.datatypes_by_extension: 
    151157                datatype = self.datatypes_by_extension[ext] 
    …… 
    158164                    self.sniff_order.append(datatype) 
    159165        append_to_sniff_order() 
    160      
     166 
    161167    def get_mimetype_by_extension(self, ext ): 
    162168        """Returns a mimetype based on an extension""" 
    …… 
    197203        newdata.ext = ext 
    198204        return newdata 
    199          
    200     def load_datatype_converters(self, datatype_converters_config, datatype_converters_path, toolbox): 
    201         """Loads datatype converters from a file, and adds to the toolbox""" 
    202         self.datatype_converters = odict()         
    203         tree = galaxy.util.parse_xml( datatype_converters_config ) 
    204         root = tree.getroot() 
    205         self.log.debug( "Loading converters from %s" % (datatype_converters_config) ) 
    206         for elem in root.findall("converter"): 
    207             path = elem.get("file") 
    208             source_datatype = elem.get("source_datatype").split(",") 
    209             target_datatype = elem.get("target_datatype") 
    210             converter = toolbox.load_tool( os.path.join( datatype_converters_path, path ) ) 
     205 
     206    def load_datatype_converters( self, toolbox ): 
     207        """Adds datatype converters from self.converters to the calling app's toolbox"""      
     208        for elem in self.converters: 
     209            tool_config = elem[0] 
     210            source_datatype = elem[1] 
     211            target_datatype = elem[2] 
     212            converter = toolbox.load_tool( os.path.join( self.datatype_converters_path, tool_config ) ) 
     213            toolbox.tools_by_id[converter.id] = converter 
     214            if source_datatype not in self.datatype_converters: 
     215                self.datatype_converters[source_datatype] = odict() 
     216            self.datatype_converters[source_datatype][target_datatype] = converter 
    211217            self.log.debug( "Loaded converter: %s", converter.id ) 
    212             toolbox.tools_by_id[converter.id] = converter 
    213             for source_d in source_datatype: 
    214                 if source_d not in self.datatype_converters: 
    215                     self.datatype_converters[source_d] = odict() 
    216                 self.datatype_converters[source_d][target_datatype] = converter 
     218 
    217219    def get_converters_by_datatype(self, ext): 
    218220        """Returns available converters by source type""" 

  • universe_wsgi.ini.sample

    r1367 r1371  
    9393# Comma separated list of UCSC / gbrowse browsers to use for viewing 
    9494ucsc_display_sites = main,test,archaea 
    95 gbrowse_display_sites = wormbase,flybase,elegans 
     95gbrowse_display_sites = elegans,flybase 
    9696 
    9797# Serving static files (needed if running standalone) 
    …… 
    118118 
    119119# Clustering Galaxy is not a straightforward process and requires a lot of 
    120 # pre-configuration.  Please see the Galaxy Wiki before attempting to set any 
     120# pre-configuration.  See the ClusteringGalaxy Wiki before attempting to set any 
    121121# of these options.  If running normally (without a cluster), do not change 
    122122# anything in this section. 
    …… 
    130130# default_cluster_job_runner: The URL for the default runner to use when a tool 
    131131# doesn't explicity define a runner below.  For help on the cluster URL format, 
    132 # see the Galaxy Wiki.  Leave commented if not using a cluster job runner. 
     132# see the ClusteringGalaxy Wiki.  Leave commented if not using a cluster job runner. 
    133133#default_cluster_job_runner = pbs:/// 
    134134 
    135 # The PBS options are described in detail on the Galaxy Wiki 
     135# The PBS options are described in detail in the Galaxy Configuration section of 
     136# the ClusteringGalaxy Wiki 
    136137#pbs_application_server =  
    137138#pbs_stage_path =  
    …… 
    163164ucsc_table_direct_test1 = local:/// 
    164165upload1 = local:/// 
    165  
    166 # ---- Datatypes ------------------------------------------------------------ 
    167  
    168 [galaxy:datatypes] 
    169  
    170 #<file extension> = <data type class>,<mime type (optional)>,<display in upload select list (optional)> 
    171 ab1 = galaxy.datatypes.images:Ab1,application/octet-stream,display_in_upload 
    172 axt = galaxy.datatypes.sequence:Axt,display_in_upload 
    173 bed = galaxy.datatypes.interval:Bed,display_in_upload 
    174 binseq.zip = galaxy.datatypes.images:Binseq,application/zip,display_in_upload 
    175 customtrack = galaxy.datatypes.interval:CustomTrack 
    176 data = galaxy.datatypes.data:Data,application/octet-stream 
    177 fasta = galaxy.datatypes.sequence:Fasta,display_in_upload 
    178 fastqsolexa = galaxy.datatypes.sequence:FastqSolexa,display_in_upload 
    179 gff = galaxy.datatypes.interval:Gff,display_in_upload 
    180 gff3 = galaxy.datatypes.interval:Gff3,display_in_upload 
    181 gif = galaxy.datatypes.images:Image,image/gif 
    182 gmaj.zip = galaxy.datatypes.images:Gmaj,application/zip 
    183 html = galaxy.datatypes.images:Html,text/html 
    184 interval = galaxy.datatypes.interval:Interval,display_in_upload 
    185 jpg = galaxy.datatypes.images:Image,image/jpeg 
    186 laj = galaxy.datatypes.images:Laj 
    187 lav = galaxy.datatypes.sequence:Lav,display_in_upload 
    188 maf = galaxy.datatypes.sequence:Maf,display_in_upload 
    189 pdf = galaxy.datatypes.images:Image,application/pdf 
    190 png = galaxy.datatypes.images:Image,image/png 
    191 qual = galaxy.datatypes.qualityscore:QualityScore,display_in_upload 
    192 scf = galaxy.datatypes.images:Scf,application/octet-stream,display_in_upload 
    193 taxonomy = galaxy.datatypes.tabular:Taxonomy,display_in_upload 
    194 tabular = galaxy.datatypes.tabular:Tabular,display_in_upload 
    195 txt = galaxy.datatypes.data:Text,display_in_upload 
    196 txtseq.zip = galaxy.datatypes.images:Txtseq,application/zip,display_in_upload 
    197 wig = galaxy.datatypes.interval:Wiggle,display_in_upload 
    198 #EMBOSS TOOLS 
    199 acedb = galaxy.datatypes.data:Text 
    200 asn1 = galaxy.datatypes.data:Text 
    201 btwisted = galaxy.datatypes.data:Text 
    202 cai =  galaxy.datatypes.data:Text 
    203 charge = galaxy.datatypes.data:Text 
    204 checktrans = galaxy.datatypes.data:Text 
    205 chips = galaxy.datatypes.data:Text 
    206 clustal = galaxy.datatypes.data:Text 
    207 codata = galaxy.datatypes.data:Text 
    208 codcmp = galaxy.datatypes.data:Text 
    209 coderet = galaxy.datatypes.data:Text 
    210 compseq = galaxy.datatypes.data:Text 
    211 cpgplot = galaxy.datatypes.data:Text 
    212 cpgreport = galaxy.datatypes.data:Text 
    213 cusp = galaxy.datatypes.data:Text 
    214 cut = galaxy.datatypes.data:Text 
    215 dan = galaxy.datatypes.data:Text 
    216 dbmotif = galaxy.datatypes.data:Text 
    217 diffseq = galaxy.datatypes.data:Text 
    218 digest = galaxy.datatypes.data:Text 
    219 dreg = galaxy.datatypes.data:Text 
    220 einverted = galaxy.datatypes.data:Text 
    221 embl = galaxy.datatypes.data:Text 
    222 epestfind = galaxy.datatypes.data:Text 
    223 equicktandem = galaxy.datatypes.data:Text 
    224 est2genome = galaxy.datatypes.data:Text 
    225 etandem = galaxy.datatypes.data:Text 
    226 excel = galaxy.datatypes.data:Text 
    227 feattable = galaxy.datatypes.data:Text 
    228 fitch = galaxy.datatypes.data:Text 
    229 freak = galaxy.datatypes.data:Text 
    230 fuzznuc = galaxy.datatypes.data:Text 
    231 fuzzpro = galaxy.datatypes.data:Text 
    232 fuzztran = galaxy.datatypes.data:Text 
    233 garnier = galaxy.datatypes.data:Text 
    234 gcg = galaxy.datatypes.data:Text 
    235 geecee = galaxy.datatypes.data:Text 
    236 genbank = galaxy.datatypes.data:Text 
    237 helixturnhelix = galaxy.datatypes.data:Text 
    238 hennig86 = galaxy.datatypes.data:Text 
    239 hmoment = galaxy.datatypes.data:Text 
    240 ig = galaxy.datatypes.data:Text 
    241 isochore = galaxy.datatypes.data:Text 
    242 jackknifer = galaxy.datatypes.data:Text 
    243 jackknifernon = galaxy.datatypes.data:Text 
    244 markx10 = galaxy.datatypes.data:Text 
    245 markx1 = galaxy.datatypes.data:Text 
    246 markx0 = galaxy.datatypes.data:Text 
    247 markx3 = galaxy.datatypes.data:Text 
    248 markx2 = galaxy.datatypes.data:Text 
    249 match = galaxy.datatypes.data:Text 
    250 mega = galaxy.datatypes.data:Text 
    251 meganon = galaxy.datatypes.data:Text 
    252 motif = galaxy.datatypes.data:Text 
    253 msf = galaxy.datatypes.data:Text 
    254 nametable = galaxy.datatypes.data:Text 
    255 ncbi = galaxy.datatypes.data:Text 
    256 needle = galaxy.datatypes.data:Text 
    257 newcpgreport = galaxy.datatypes.data:Text 
    258 newcpgseek = galaxy.datatypes.data:Text 
    259 nexus = galaxy.datatypes.data:Text 
    260 nexusnon = galaxy.datatypes.data:Text 
    261 noreturn = galaxy.datatypes.data:Text 
    262 pair = galaxy.datatypes.data:Text 
    263 palindrome = galaxy.datatypes.data:Text 
    264 pepcoil = galaxy.datatypes.data:Text 
    265 pepinfo = galaxy.datatypes.data:Text 
    266 pepstats = galaxy.datatypes.data:Text 
    267 phylip = galaxy.datatypes.data:Text 
    268 phylipnon = galaxy.datatypes.data:Text 
    269 pir = galaxy.datatypes.data:Text 
    270 polydot = galaxy.datatypes.data:Text 
    271 preg = galaxy.datatypes.data:Text 
    272 prettyseq = galaxy.datatypes.data:Text 
    273 primersearch = galaxy.datatypes.data:Text 
    274 regions = galaxy.datatypes.data:Text 
    275 score = galaxy.datatypes.data:Text 
    276 selex = galaxy.datatypes.data:Text 
    277 seqtable = galaxy.datatypes.data:Text 
    278 showfeat = galaxy.datatypes.data:Text 
    279 showorf = galaxy.datatypes.data:Text  
    280 simple = galaxy.datatypes.data:Text 
    281 sixpack = galaxy.datatypes.data:Text 
    282 srs = galaxy.datatypes.data:Text 
    283 srspair = galaxy.datatypes.data:Text 
    284 staden = galaxy.datatypes.data:Text 
    285 strider = galaxy.datatypes.data:Text 
    286 supermatcher = galaxy.datatypes.data:Text 
    287 swiss = galaxy.datatypes.data:Text 
    288 syco = galaxy.datatypes.data:Text 
    289 table = galaxy.datatypes.data:Text 
    290 textsearch = galaxy.datatypes.data:Text 
    291 vectorstrip = galaxy.datatypes.data:Text 
    292 wobble = galaxy.datatypes.data:Text 
    293 wordcount = galaxy.datatypes.data:Text 
    294 tagseq = galaxy.datatypes.data:Text 
    295  
    296 # ---- Data Type Sniff Order -------------------------------------------------- 
    297  
    298 [galaxy:sniff_order] 
    299  
    300 05 = galaxy.datatypes.sequence:Maf 
    301 10 = galaxy.datatypes.sequence:Lav 
    302 15 = galaxy.datatypes.sequence:Fasta 
    303 20 = galaxy.datatypes.sequence:Fastq 
    304 25 = galaxy.datatypes.sequence:FastqSolexa 
    305 30 = galaxy.datatypes.interval:Wiggle 
    306 35 = galaxy.datatypes.images:Html 
    307 40 = galaxy.datatypes.sequence:Axt 
    308 45 = galaxy.datatypes.interval:Bed 
    309 50 = galaxy.datatypes.interval:CustomTrack 
    310 55 = galaxy.datatypes.interval:Gff 
    311 60 = galaxy.datatypes.interval:Gff3 
    312 65 = galaxy.datatypes.interval:Interval