Changeset 1733:548d1187a29f in orange-bioinformatics for _bioinformatics/obiKEGG/databases.py


Ignore:
Timestamp:
03/05/13 19:48:00 (14 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Porting obiKEGG to use the new REST KEGG API.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _bioinformatics/obiKEGG/databases.py

    r1716 r1733  
    1010from . import api 
    1111 
     12 
    1213def iter_take(source_iter, n): 
    1314    source_iter = iter(source_iter) 
    1415    return [item for _, item in zip(range(n), source_iter)] 
     16 
    1517 
    1618def batch_iter(source_iter, n): 
     
    2224        else: 
    2325            break 
    24          
     26 
     27 
    2528def chain_iter(chains_iter): 
    2629    for iter in chains_iter: 
     
    2831            yield element 
    2932 
     33 
     34# TODO: DBDataBase should be able to be constructed from a flat text 
     35# entry file. The precache etc. should be moved in caching api, that creates 
     36# simple file system hierarchy where the flat database is saved (with db 
     37# release string), e.g. 
     38# genes/hsa.dbget 
     39# genes/hsa.release 
     40# genes/sce.dbget 
     41# path.dbget 
     42# module.dbget 
     43# ligand/compound.dbget 
     44 
     45 
    3046class DBDataBase(object): 
    31     """ A wrapper for DBGET database. 
     47    """ 
     48    A wrapper for DBGET database. 
     49 
    3250    """ 
    3351    # ENTRY_TYPE constructor (type) 
    3452    ENTRY_TYPE = entry.DBEntry 
    35      
    36     # Needs to be set in a subclass or object instance  
     53 
     54    # A database name/abbreviation (e.g. path). Needs to be set in a 
     55    # subclass or object instance's constructor 
    3756    DB = None 
    38      
     57 
    3958    def __init__(self, **kwargs): 
    4059        if not self.DB: 
    41             raise TypeError("Cannot make an instance of abstract base class %r." \ 
    42                             % type(self).__name__) 
    43              
     60            raise TypeError("Cannot make an instance of abstract base " 
     61                            "class %r." % type(self).__name__) 
     62 
    4463        self.api = api.CachedKeggApi() 
    45         self.info = self.api.binfo(self.DB) 
     64        self.info = self.api.info(self.DB) 
    4665        release = self.info.release 
    4766        self.api.set_default_release(release) 
    4867        self._keys = [] 
    49          
     68 
    5069    def keys(self): 
     70        """ 
     71        Return a list of database keys. These are unique kegg identifiers 
     72        that can be used to query the database. 
     73 
     74        """ 
    5175        return list(self._keys) 
    52      
     76 
    5377    def iterkeys(self): 
     78        """ 
     79        Return an iterator over the `keys` 
     80        """ 
    5481        return iter(self._keys) 
    55      
     82 
    5683    def items(self): 
     84        """ 
     85        Return a list of all (key, `ENTRY_TYPE` instance) tuples. 
     86        """ 
    5787        return list(zip(self.keys(), self.batch_get(self.keys()))) 
    58      
     88 
    5989    def iteritems(self): 
     90        """ 
     91        Return an iterator over the `items`. 
     92        """ 
    6093        batch_size = 100 
    6194        iterkeys = self.iterkeys() 
    6295        return chain_iter(zip(batch, self.batch_get(batch)) 
    6396                          for batch in batch_iter(iterkeys, batch_size)) 
    64          
    65 #        return ((key, self.__getitem__(key)) for key in self.iterkeys()) 
    66      
     97 
    6798    def values(self): 
     99        """ 
     100        Return a list of all `ENTRY_TYPE` instances. 
     101        """ 
    68102        return self.batch_get(self.keys()) 
    69      
     103 
    70104    def itervalues(self): 
     105        """ 
     106        Return an iterator over all `ENTRY_TYPE` instances. 
     107        """ 
    71108        batch_size = 100 
    72109        iterkeys = self.iterkeys() 
    73110        return chain_iter(self.batch_get(batch) 
    74111                          for batch in batch_iter(iterkeys, batch_size)) 
    75          
    76 #        return (self.__getitem__(key) for key in self.iterkeys()) 
    77      
     112 
    78113    def get(self, key, default=None): 
     114        """ 
     115        Return an `ENTRY_TYPE` instance for the `key`. Raises `KeyError` if 
     116        not found. 
     117 
     118        """ 
    79119        try: 
    80120            return self.__getitem__(key) 
    81121        except KeyError: 
    82122            return default 
    83          
     123 
    84124    def has_key(self, key): 
    85125        return self.__contains__(key) 
    86      
     126 
    87127    def __getitem__(self, key): 
    88128        e = self.get_entry(key) 
     
    91131        else: 
    92132            return e 
    93      
     133 
    94134    def __contains__(self, key): 
    95135        return key in set(self.keys()) 
    96      
     136 
    97137    def __len__(self): 
    98138        return len(self.keys()) 
    99      
     139 
    100140    def __iter__(self): 
    101141        return iter(self.keys()) 
    102      
     142 
    103143    def get_text(self, key): 
     144        """ 
     145        Return the database entry for `key` as plain text. 
     146        """ 
    104147        key = self._add_db(key) 
    105         return self.api.bget([key]) 
    106      
     148        return self.api.get([key]) 
     149 
    107150    def get_entry(self, key): 
     151        """ 
     152        Return the database entry for `key` as an instance of `ENTRY_TYPE`. 
     153        """ 
    108154        text = self.get_text(key) 
    109155        if not text or text == "None": 
     
    111157        else: 
    112158            return self.ENTRY_TYPE(text) 
    113          
     159 
    114160    def find(self, name): 
    115         """ Find ``name`` using BFIND.  
    116         """ 
    117         res = self.api.bfind(self.DB, name).splitlines() 
    118         return [r.split(" ", 1)[0] for r in res]     
    119          
    120     def pre_cache(self, keys=None, batch_size=100, progress_callback=None): 
    121         """ Retrive all the entries and cache them locally. 
     161        """ 
     162        Find ``name`` using kegg ``find`` api. 
     163        """ 
     164        res = self.api.find(self.DB, name).splitlines() 
     165        return [r.split(" ", 1)[0] for r in res] 
     166 
     167    def pre_cache(self, keys=None, batch_size=10, progress_callback=None): 
     168        """ 
     169        Retrieve all the entries and cache them locally. 
    122170        """ 
    123171        # TODO do this in multiple threads 
    124      
     172 
    125173        if not isinstance(self.api, api.CachedKeggApi): 
    126             raise TypeError("Not an an instance of api.CachedKeggApi") 
    127          
    128         if batch_size > 100 or batch_size < 1: 
     174            raise TypeError("Not an instance of api.CachedKeggApi") 
     175 
     176        if batch_size > 10 or batch_size < 1: 
    129177            raise ValueError("Invalid batch_size") 
    130          
     178 
    131179        if keys is None: 
    132180            keys = self.keys() 
    133              
     181 
    134182        keys = list(keys) 
    135183        start = 0 
     
    137185            batch = keys[start: start + batch_size] 
    138186            batch = map(self._add_db, batch) 
    139              
    140             self.api.bget(batch) 
    141              
     187 
     188            self.api.get(batch) 
     189 
    142190            if progress_callback: 
    143191                progress_callback(100.0 * start / len(keys)) 
    144                  
     192 
    145193            start += batch_size 
    146              
     194 
    147195    def batch_get(self, keys): 
    148         """ Batch retrieve all entries for keys. This can be 
    149         significantly faster then getting each entry separately 
    150         especially if entries are not yet cached. 
    151          
     196        """ 
     197        Batch retrieve all entries for keys. This can be significantly 
     198        faster then getting each entry separately especially if entries 
     199        are not yet cached. 
     200 
    152201        """ 
    153202        entries = [] 
     
    158207            batch = keys[start: start + batch_size] 
    159208            batch = map(self._add_db, batch) 
    160             batch_entries = self.api.bget(batch) 
     209            batch_entries = self.api.get(batch) 
    161210            if batch_entries is not None: 
    162211                batch_entries = batch_entries.split("///\n") 
    163                 # Remove possible empty last line   
     212                # Remove possible empty last line 
    164213                batch_entries = [e for e in batch_entries if e.strip()] 
    165214                entries.extend(map(self.ENTRY_TYPE, batch_entries)) 
    166215            start += batch_size 
    167              
     216 
    168217        return entries 
    169              
     218 
    170219    def _add_db(self, key): 
    171         """ Prefix the key with '%(DB)s:' string if not already 
    172         prefixed.  
     220        """ 
     221        Prefix the key with '%(DB)s:' string if not already prefixed. 
    173222        """ 
    174223        if not key.startswith(self.DB + ":"): 
     
    176225        else: 
    177226            return key 
    178          
    179     @property 
    180     def entries(self): 
    181         return self.values() 
    182      
     227 
     228 
    183229@entry.entry_decorate 
    184230class GenomeEntry(entry.DBEntry): 
    185     FIELDS = [("ENTRY", fields.DBEntryField), 
    186               ("NAME", fields.DBNameField), 
    187               ("DEFINITION", fields.DBDefinitionField), 
    188               ("ANNOTATION", fields.DBSimpleField), 
    189               ("TAXONOMY", fields.DBTaxonomyField), 
    190               ("DATA_SOURCE", fields.DBSimpleField), 
    191               ("ORIGINAL_DB", fields.DBSimpleField), 
    192               ("KEYWORDS", fields.DBSimpleField), 
    193               ("DISEASE", fields.DBSimpleField), 
    194               ("COMMENT", fields.DBSimpleField), 
    195               ("CHROMOSOME", fields.DBFieldWithSubsections), 
    196               ("STATISTICS", fields.DBSimpleField), 
    197               ("REFERENCE", fields.DBReference)] 
    198      
     231    """ 
     232    Entry for a KEGG Genome database. 
     233    """ 
     234    FIELDS = [ 
     235        ("ENTRY", fields.DBEntryField), 
     236        ("NAME", fields.DBNameField), 
     237        ("DEFINITION", fields.DBDefinitionField), 
     238        ("ANNOTATION", fields.DBSimpleField), 
     239        ("TAXONOMY", fields.DBTaxonomyField), 
     240        ("DATA_SOURCE", fields.DBSimpleField), 
     241        ("ORIGINAL_DB", fields.DBSimpleField), 
     242        ("KEYWORDS", fields.DBSimpleField), 
     243        ("DISEASE", fields.DBSimpleField), 
     244        ("COMMENT", fields.DBSimpleField), 
     245        ("CHROMOSOME", fields.DBFieldWithSubsections), 
     246        ("PLASMID", fields.DBSimpleField), 
     247        ("STATISTICS", fields.DBSimpleField), 
     248        ("REFERENCE", fields.DBReference) 
     249    ] 
     250 
    199251    MULTIPLE_FIELDS = ["REFERENCE"] 
    200      
     252 
    201253    def __init__(self, text): 
    202254        entry.DBEntry.__init__(self, text) 
    203          
     255 
    204256    @property 
    205     def entry_key(self): 
    206         """ Primary entry key used for querying. 
    207          
    208         .. note:: Unlike most of the other entry types this is the 
    209             first listed 'NAME'. 
    210              
    211         """ 
    212          
     257    def organism_code(self): 
     258        """ 
     259        A three or four letter KEGG organism code (e.g. 'hsa', 'sce', ...) 
     260        """ 
    213261        return self.name.split(",", 1)[0] 
    214262 
    215263    @property 
    216264    def taxid(self): 
     265        """ 
     266        Organism NCBI taxonomy id. 
     267        """ 
    217268        return self.TAXONOMY.taxid 
    218              
    219     def org_code(self): 
    220         if self.name is not None: 
    221             return self.name.split(",")[0] 
    222         else: 
    223             return self.entry.split(" ")[0] 
    224          
     269 
     270#    def org_code(self): 
     271#        if self.name is not None: 
     272#            return self.name.split(",")[0] 
     273#        else: 
     274#            return self.entry.split(" ")[0] 
     275 
    225276 
    226277class Genome(DBDataBase): 
     278    """ 
     279    An interface to the A KEGG GENOME database. 
     280    """ 
    227281    DB = "genome" 
    228282    ENTRY_TYPE = GenomeEntry 
    229      
     283 
    230284    # For obiTaxonomy.common_taxids mapping 
    231     TAXID_MAP = {"562": "511145",   # Escherichia coli K-12 MG1655 
    232                  "2104": "272634",  # Mycoplasma pneumoniae M129  
    233                  "4530": "39947",   # Oryza sativa ssp. japonica cultivar Nipponbare (Japanese rice) 
    234                  "4932" : "559292", # Saccharomyces cerevisiae S288C 
    235                  "4896": "284812",  # Schizosaccharomyces pombe 972h- 
    236                  } 
    237      
     285    TAXID_MAP = { 
     286        "562": "511145",   # Escherichia coli K-12 MG1655 
     287        "2104": "272634",  # Mycoplasma pneumoniae M129 
     288        "4530": "39947",   # Oryza sativa ssp. japonica cultivar Nipponbare (Japanese rice) 
     289        "4932": "559292",  # Saccharomyces cerevisiae S288C 
     290        "4896": "284812",  # Schizosaccharomyces pombe 972h- 
     291    } 
     292 
    238293    def __init__(self): 
    239294        DBDataBase.__init__(self) 
    240         self._keys = [org.entry_id for org in self.api.list_organisms()] 
    241      
     295        self._org_list = self.api.list_organisms() 
     296        self._keys = [org.entry_id for org in self._org_list] 
     297 
    242298    def _key_to_gn_entry_id(self, key): 
    243299        res = self.find(key) 
     
    248304        else: 
    249305            return res[0] 
    250      
     306 
    251307    @classmethod 
    252308    def common_organisms(cls): 
     
    254310                'dme', 'eco', 'hsa', 'mmu', 'mpn', 'osa', 
    255311                'pfa', 'rno', 'sce', 'spo', 'zma', 'xla'] 
    256          
     312 
    257313    @classmethod 
    258314    def essential_organisms(cls): 
    259315        return ['ddi', 'dme', 'hsa', 'mmu', 'sce'] 
    260      
     316 
     317    def org_code_to_entry_key(self, code): 
     318        """ 
     319        Map an organism code ('hsa', 'sce', ...) to the corresponding kegg 
     320        identifier (T + 5 digit number). 
     321 
     322        """ 
     323        for org in self._org_list: 
     324            if org.org_code == code: 
     325                return org.entry_id 
     326        else: 
     327            raise ValueError("Unknown organism code '%s'" % code) 
     328 
    261329    def search(self, string, relevance=False): 
    262         """ Search the genome database for string using ``bfind``. 
     330        """ 
     331        Search the genome database for string using ``bfind``. 
    263332        """ 
    264333        if relevance: 
    265334            raise NotImplementedError("relevance is no longer supported") 
     335 
    266336        if string in self.TAXID_MAP: 
    267337            string = self.TAXID_MAP[string] 
    268              
    269         res = self.api.bfind(self.DB, string) 
     338 
     339        res = self.api.find(self.DB, string) 
    270340        if not res: 
    271341            return [] 
    272          
     342 
    273343        res = res.splitlines() 
    274344        res = [r.split(",", 1)[0] for r in res] 
    275         res = [r.split(" ", 1)[1] for r in res] 
     345        res = [r.split(None, 1)[1] for r in res] 
    276346        return res 
    277      
    278      
     347 
     348 
    279349@entry.entry_decorate 
    280350class GeneEntry(entry.DBEntry): 
    281     FIELDS = [("ENTRY", fields.DBEntryField), 
    282               ("NAME", fields.DBNameField), 
    283               ("DEFINITION", fields.DBDefinitionField), 
    284               ("ORGANISM", fields.DBSimpleField), 
    285               ("ORTHOLOGY", fields.DBSimpleField), 
    286               ("DRUG_TARGET", fields.DBSimpleField), 
    287               ("PATHWAY", fields.DBPathway), 
    288               ("MODULE", fields.DBSimpleField), 
    289               ("DISEASE", fields.DBSimpleField), 
    290               ("CLASS", fields.DBSimpleField), 
    291               ("POSITION", fields.DBSimpleField), 
    292               ("MOTIF", fields.DBSimpleField), 
    293               ("DBLINKS", fields.DBDBLinks), 
    294               ("STRUCTURE", fields.DBSimpleField), 
    295               ("AASEQ", fields.DBAASeq), 
    296               ("NTSEQ", fields.DBNTSeq)] 
    297      
     351    FIELDS = [ 
     352        ("ENTRY", fields.DBEntryField), 
     353        ("NAME", fields.DBNameField), 
     354        ("DEFINITION", fields.DBDefinitionField), 
     355        ("ORTHOLOGY", fields.DBSimpleField), 
     356        ("ORGANISM", fields.DBSimpleField), 
     357        ("PATHWAY", fields.DBPathway), 
     358        ("MODULE", fields.DBSimpleField), 
     359        ("DISEASE", fields.DBSimpleField), 
     360        ("DRUG_TARGET", fields.DBSimpleField), 
     361        ("CLASS", fields.DBSimpleField), 
     362        ("MOTIF", fields.DBSimpleField), 
     363        ("DBLINKS", fields.DBDBLinks), 
     364        ("STRUCTURE", fields.DBSimpleField), 
     365        ("POSITION", fields.DBSimpleField), 
     366        ("AASEQ", fields.DBAASeq), 
     367        ("NTSEQ", fields.DBNTSeq) 
     368    ] 
     369 
    298370    def aliases(self): 
    299         return [self.entry_key] + (self.name.split(",") if self.name else []) + [link[1][0] for link in self.dblinks.items() if self.dblinks] 
     371        return [self.entry_key] + \ 
     372               (self.name.split(",") if self.name else []) + \ 
     373               ([link[1][0] for link in self.dblinks.items()] 
     374                if self.dblinks else []) 
    300375 
    301376    @property 
    302377    def alt_names(self): 
    303         """ For backwards compatibility. 
     378        """ 
     379        For backwards compatibility. 
    304380        """ 
    305381        return self.aliases() 
    306    
     382 
     383 
    307384class Genes(DBDataBase): 
    308     DB = None # Needs to be set in __init__  
     385    DB = None  # Needs to be set in __init__ 
    309386    ENTRY_TYPE = GeneEntry 
    310      
     387 
    311388    def __init__(self, org_code): 
     389        # TODO: Map to org code from kegg id (T + 5 digits) 
    312390        self.DB = org_code 
    313391        self.org_code = org_code 
    314392        DBDataBase.__init__(self) 
    315393        self._keys = self.api.get_genes_by_organism(org_code) 
    316          
     394 
    317395    def gene_aliases(self): 
    318396        aliases = {} 
    319397        for entry in self.itervalues(): 
    320             aliases.update(dict.fromkeys(entry.aliases(), self.org_code + ":" + entry.entry_key())) 
     398            aliases.update(dict.fromkeys(entry.aliases(), 
     399                                         self.org_code + ":" + entry.entry_key)) 
    321400        return aliases 
    322      
     401 
    323402 
    324403@entry.entry_decorate 
    325404class CompoundEntry(entry.DBEntry): 
    326     FIELDS = [("ENTRY", fields.DBEntryField), 
    327               ("NAME", fields.DBNameField), 
    328               ("FORMULA", fields.DBSimpleField), 
    329               ("MASS", fields.DBSimpleField), 
    330               ("REMARK", fields.DBSimpleField), 
    331               ("REACTION", fields.DBSimpleField), 
    332               ("PATHWAY", fields.DBPathway), 
    333               ("ENZYME", fields.DBSimpleField), 
    334               ("DBLINKS", fields.DBDBLinks), 
    335               ("ATOM", fields.DBSimpleField), 
    336               ("BOND", fields.DBSimpleField) 
    337               ] 
    338      
    339      
    340 class Compounds(DBDataBase): 
     405    FIELDS = [ 
     406        ("ENTRY", fields.DBEntryField), 
     407        ("NAME", fields.DBNameField), 
     408        ("FORMULA", fields.DBSimpleField), 
     409        ("EXACT_MASS", fields.DBSimpleField), 
     410        ("MOL_WEIGHT", fields.DBSimpleField), 
     411        ("REMARK", fields.DBSimpleField), 
     412        ("COMMENT", fields.DBSimpleField), 
     413        ("REACTION", fields.DBSimpleField), 
     414        ("PATHWAY", fields.DBPathway), 
     415        ("ENZYME", fields.DBSimpleField), 
     416        ("BRITE", fields.DBSimpleField), 
     417        ("REFERENCE", fields.DBSimpleField), 
     418        ("DBLINKS", fields.DBDBLinks), 
     419        ("ATOM", fields.DBSimpleField), 
     420        ("BOND", fields.DBSimpleField) 
     421    ] 
     422 
     423 
     424class Compound(DBDataBase): 
    341425    DB = "cpd" 
    342426    ENTRY_TYPE = CompoundEntry 
    343      
     427 
    344428    def __init__(self): 
    345429        DBDataBase.__init__(self) 
    346         self._keys = [] # All keys are not available 
    347  
    348  
    349 @entry.entry_decorate     
     430        self._keys = [d.entry_id for d in self.api.list("cpd")] 
     431 
     432 
     433@entry.entry_decorate 
    350434class ReactionEntry(entry.DBEntry): 
    351     FIELDS = [("ENTRY", fields.DBEntryField), 
    352               ("NAME", fields.DBNameField), 
    353               ("DEFINITION", fields.DBDefinitionField), 
    354               ("EQUATION", fields.DBSimpleField), 
    355               ("ENZYME", fields.DBSimpleField) 
    356               ] 
    357      
    358 class Reactions(DBDataBase): 
     435    FIELDS = [ 
     436        ("ENTRY", fields.DBEntryField), 
     437        ("NAME", fields.DBNameField), 
     438        ("DEFINITION", fields.DBDefinitionField), 
     439        ("EQUATION", fields.DBSimpleField), 
     440        ("ENZYME", fields.DBSimpleField) 
     441    ] 
     442 
     443 
     444class Reaction(DBDataBase): 
    359445    DB = "rn" 
    360446    ENTRY_TYPE = ReactionEntry 
    361      
     447 
    362448    def __init__(self): 
    363449        DBDataBase.__init__(self) 
    364         self._keys = [] # All keys are not available 
    365           
     450        self._keys = [d.entry_id for d in self.api.list("rn")] 
     451 
     452 
    366453class Brite(DBDataBase): 
    367454    DB = "br" 
    368      
     455 
     456 
    369457class Disease(DBDataBase): 
    370458    DB = "ds" 
    371          
     459 
     460 
    372461class Drug(DBDataBase): 
    373462    DB = "dr" 
    374      
     463 
     464 
    375465@entry.entry_decorate 
    376466class EnzymeEntry(entry.DBEntry): 
    377     FIELDS = [("ENTRY", fields.DBEntryField), 
    378               ("NAME", fields.DBNameField), 
    379               ("CLASS", fields.DBSimpleField), 
    380               ("SYSNAME", fields.DBSimpleField), 
    381               ("REACTION", fields.DBSimpleField), 
    382               ("ALL_REAC", fields.DBSimpleField), 
    383               ("SUBSTRATE", fields.DBSimpleField), 
    384               ("PRODUCT", fields.DBSimpleField), 
    385               ("COMMENT", fields.DBSimpleField), 
    386               ("REFERENCE", fields.DBReference), 
    387               ("PATHWAY", fields.DBPathway), 
    388               ("ORTHOLOGY", fields.DBSimpleField), 
    389               ("GENES", fields.DBSimpleField), 
    390               ("DBLINKS", fields.DBDBLinks) 
    391               ] 
    392      
     467    FIELDS = [ 
     468        ("ENTRY", fields.DBEntryField), 
     469        ("NAME", fields.DBNameField), 
     470        ("CLASS", fields.DBSimpleField), 
     471        ("SYSNAME", fields.DBSimpleField), 
     472        ("REACTION", fields.DBSimpleField), 
     473        ("ALL_REAC", fields.DBSimpleField), 
     474        ("SUBSTRATE", fields.DBSimpleField), 
     475        ("PRODUCT", fields.DBSimpleField), 
     476        ("COMMENT", fields.DBSimpleField), 
     477        ("REFERENCE", fields.DBReference), 
     478        ("PATHWAY", fields.DBPathway), 
     479        ("ORTHOLOGY", fields.DBSimpleField), 
     480        ("GENES", fields.DBSimpleField), 
     481        ("DBLINKS", fields.DBDBLinks) 
     482    ] 
     483 
    393484    MULTIPLE_FIELDS = ["REFERENCE"] 
    394      
    395 class Enzymes(DBDataBase): 
     485 
     486 
     487class Enzyme(DBDataBase): 
    396488    DB = "ec" 
    397489    ENTRY_TYPE = EnzymeEntry 
    398      
    399      
     490 
     491    def __init__(self): 
     492        DBDataBase.__init__(self) 
     493        self._keys = [d.entry_id for d in self.api.list("ec")] 
     494 
     495 
    400496@entry.entry_decorate 
    401497class OrthologyEntry(entry.DBEntry): 
    402     FIELDS = [("ENTRY", fields.DBEntryField), 
    403               ("NAME", fields.DBNameField), 
    404               ("CLASS", fields.DBSimpleField), 
    405               ("DBLINKS", fields.DBDBLinks), 
    406               ("GENES", fields.DBSimpleField), 
    407               ] 
    408      
     498    FIELDS = [ 
     499        ("ENTRY", fields.DBEntryField), 
     500        ("NAME", fields.DBNameField), 
     501        ("CLASS", fields.DBSimpleField), 
     502        ("DBLINKS", fields.DBDBLinks), 
     503        ("GENES", fields.DBSimpleField), 
     504    ] 
     505 
     506 
    409507class Orthology(DBDataBase): 
    410508    DB = "ko" 
    411509    ENTRY_TYPE = OrthologyEntry 
    412      
    413      
     510 
     511    def __init__(self): 
     512        DBDataBase.__init__(self) 
     513        self._keys = [d.entry_id for d in self.api.list("ko")] 
     514 
     515 
    414516@entry.entry_decorate 
    415517class PathwayEntry(entry.DBEntry): 
    416     FIELDS = [("ENTRY", fields.DBEntryField), 
    417               ("NAME", fields.DBNameField), 
    418               ("DESCRIPTION", fields.DBSimpleField), 
    419               ("CLASS", fields.DBSimpleField), 
    420               ("PATHWAY_MAP", fields.DBPathwayMapField), 
    421               ("DISEASE", fields.DBSimpleField), 
    422               ("DRUG", fields.DBSimpleField), 
    423               ("DBLINKS", fields.DBDBLinks), 
    424               ("ORGANISM", fields.DBSimpleField), 
    425               ("GENE", fields.DBGeneField), 
    426               ("ENZYME", fields.DBEnzymeField), 
    427               ("COMPOUND", fields.DBCompoundField), 
    428               ("REFERENCE", fields.DBReference), 
    429               ("REL_PATHWAY", fields.DBSimpleField), 
    430               ("KO_PATHWAY", fields.DBSimpleField), 
    431               ] 
    432      
     518    FIELDS = [ 
     519        ("ENTRY", fields.DBEntryField), 
     520        ("NAME", fields.DBNameField), 
     521        ("DESCRIPTION", fields.DBSimpleField), 
     522        ("CLASS", fields.DBSimpleField), 
     523        ("PATHWAY_MAP", fields.DBPathwayMapField), 
     524        ("MODULE", fields.DBSimpleField), 
     525        ("DISEASE", fields.DBSimpleField), 
     526        ("DRUG", fields.DBSimpleField), 
     527        ("DBLINKS", fields.DBDBLinks), 
     528        ("ORGANISM", fields.DBSimpleField), 
     529        ("GENE", fields.DBGeneField), 
     530        ("ENZYME", fields.DBEnzymeField), 
     531        ("COMPOUND", fields.DBCompoundField), 
     532        ("REFERENCE", fields.DBReference), 
     533        ("REL_PATHWAY", fields.DBSimpleField), 
     534        ("KO_PATHWAY", fields.DBSimpleField), 
     535    ] 
     536 
    433537    MULTIPLE_FIELDS = ["REFERENCE"] 
    434      
     538 
    435539    @property 
    436540    def gene(self): 
     
    439543        else: 
    440544            return None 
    441          
     545 
    442546        org = self.organism 
    443547        org_prefix = "" 
     
    447551                org_prefix = match[0] + ":" 
    448552        genes = [org_prefix + g for g in genes] 
    449         return genes  
    450      
    451 class Pathways(DBDataBase): 
     553        return genes 
     554 
     555 
     556class Pathway(DBDataBase): 
    452557    DB = "path" 
    453558    ENTRY_TYPE = PathwayEntry 
    454      
     559 
    455560    def __init__(self): 
    456561        DBDataBase.__init__(self) 
    457      
     562        self._keys = [d.entry_id for d in self.api.list("path")] 
Note: See TracChangeset for help on using the changeset viewer.