Changeset 1734:91d14dd2cf0e in orange-bioinformatics


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

obiKEGG code style fixes.

Location:
_bioinformatics/obiKEGG
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • _bioinformatics/obiKEGG/__init__.py

    r1733 r1734  
    2525from Orange.utils import lru_cache 
    2626from Orange.utils import progress_bar_milestones 
    27 from Orange.utils import deprecated_keywords, deprecated_attribute, \ 
    28                          deprecated_function_name 
     27from Orange.utils import ( 
     28    deprecated_keywords, deprecated_attribute, deprecated_function_name 
     29) 
    2930 
    3031from .. import obiProb 
     
    105106        else: 
    106107            return [p.entry_id for p in self.api.list_pathways(self.org_code)] 
    107      
     108 
    108109    def list_pathways(self): 
    109110        """ 
     
    112113        # NOTE: remove/deprecate and use pathways() 
    113114        return self.pathways() 
    114      
     115 
    115116    def get_linked_pathways(self, pathway_id): 
    116117        self.api.get_linked_pathways(pathway_id) 
    117          
     118 
    118119    def enzymes(self, genes=None): 
    119120        raise NotImplementedError() 
    120      
     121 
    121122    def _gm_gene_aliases(self): 
    122123        """ 
     
    195196    def get_enzymes_by_pathway(self, pathway_id): 
    196197        return KEGGPathway(pathway_id).enzymes() 
    197      
     198 
    198199    def get_compounds_by_pathway(self, pathway_id): 
    199200        return KEGGPathway(pathway_id).compounds() 
    200      
     201 
    201202    def get_pathways_by_genes(self, gene_ids): 
    202203        return self.api.get_pathways_by_genes(gene_ids) 
     
    230231    def get_compounds_by_enzyme(self, enzyme_id): 
    231232        return self._enzymes_to_compounds.get(enzyme_id) 
    232      
     233 
    233234    @deprecated_keywords({"caseSensitive": "case_sensitive"}) 
    234235    def get_unique_gene_ids(self, genes, case_sensitive=True): 
     
    265266                ids = [id for id in ids if genome.search(id)] 
    266267            name = ids.pop(0) if ids else name 
    267              
     268 
    268269        try: 
    269270            return genome[name].organism_code 
    270271        except KeyError: 
    271272            raise OrganismNotFoundError(name) 
    272          
     273 
    273274    @classmethod 
    274275    def organism_version(cls, name): 
     
    280281    def _set_genematcher(self, genematcher): 
    281282        setattr(self, "_genematcher", genematcher) 
    282          
     283 
    283284    def _get_genematcher(self): 
    284         if getattr(self, "_genematcher", None) == None: 
     285        if getattr(self, "_genematcher", None) is None: 
    285286            from .. import obiGene 
    286287            if self.org_code == "ddi": 
    287288                self._genematcher = obiGene.matcher( 
    288289                    [obiGene.GMKEGG(self.org_code), obiGene.GMDicty(), 
    289                     [obiGene.GMKEGG(self.org_code), obiGene.GMDicty()]] 
     290                     [obiGene.GMKEGG(self.org_code), obiGene.GMDicty()]] 
    290291                ) 
    291292            else: 
     
    295296            self._genematcher.set_targets(self.genes.keys()) 
    296297        return self._genematcher 
    297      
     298 
    298299    genematcher = property(_get_genematcher, _set_genematcher) 
    299300 
     
    305306    return KEGGOrganism.organism_name_search(name) 
    306307 
     308 
    307309def pathways(org): 
    308310    return KEGGPathway.list(org) 
    309311 
     312 
    310313def organisms(): 
    311314    return KEGGOrganism.organisms() 
     315 
    312316 
    313317def from_taxid(taxid): 
     
    316320    for r in res: 
    317321        e = genome[r] 
    318          
    319         if e.taxid in [taxid,  genome.TAXID_MAP.get(taxid, taxid)]: 
     322 
     323        if e.taxid in [taxid, genome.TAXID_MAP.get(taxid, taxid)]: 
    320324            return e.org_code() 
    321325 
    322326    return None 
     327 
    323328 
    324329def to_taxid(name): 
     
    333338        return None 
    334339 
     340 
    335341def create_gene_sets(): 
    336342    pass 
  • _bioinformatics/obiKEGG/api.py

    r1733 r1734  
    332332    from Orange.utils import lru_cache 
    333333 
    334      
     334 
    335335class CachedKeggApi(KeggApi): 
    336336    def __init__(self, store=None): 
     
    338338        if store is None: 
    339339            self.store = {} 
    340      
     340 
    341341    # Needed API for cached decorator. 
    342342    def cache_store(self): 
     
    346346        return caching.Sqlite3Store(os.path.join(path, 
    347347                                                 "kegg_api_cache_1.sqlite3")) 
    348      
     348 
    349349    def last_modified(self, args, kwargs=None): 
    350350        return getattr(self, "default_release", "") 
    351      
     351 
    352352    def set_default_release(self, release): 
    353353        self.default_release = release 
     
    356356    def list_organisms(self): 
    357357        return KeggApi.list_organisms(self) 
    358      
     358 
    359359    @cached_method 
    360360    def list_pathways(self, organism): 
     
    489489    # SSDB 
    490490    ###### 
    491      
     491 
    492492    @cached_method 
    493493    def get_best_best_neighbors_by_gene(self, genes_id, offset, limit): 
    494         return KeggApi.get_best_best_neighbors_by_gene(self, genes_id, offset, limit) 
    495      
     494        return KeggApi.get_best_best_neighbors_by_gene(self, genes_id, offset, 
     495                                                       limit) 
     496 
    496497    @cached_method 
    497498    def get_best_neighbors_by_gene(self, genes_id, offset, limit): 
    498         return KeggApi.get_best_neighbors_by_gene(self, genes_id, offset, limit) 
    499      
     499        return KeggApi.get_best_neighbors_by_gene(self, genes_id, offset, 
     500                                                  limit) 
     501 
    500502    @cached_method 
    501503    def get_reverse_best_neighbors_by_gene(self, genes_id, offset, limit): 
    502         return KeggApi.get_reverse_best_neighbors_by_gene(self, genes_id, offset, limit) 
    503      
     504        return KeggApi.get_reverse_best_neighbors_by_gene(self, genes_id, 
     505                                                          offset, limit) 
     506 
    504507    @cached_method 
    505508    def get_paralogs_by_gene(self, genes_id, offset, limit): 
    506509        return KeggApi.get_paralogs_by_gene(self, genes_id, offset, limit) 
    507      
     510 
    508511    ####### 
    509512    # Motif 
    510513    ####### 
    511      
     514 
    512515    @cached_method 
    513516    def get_motifs_by_gene(self, genes_id, db): 
    514517        return KeggApi.get_motifs_by_gene(self, genes_id, db) 
    515      
     518 
    516519    @cached_method 
    517520    def get_genes_by_motifs(self, motif_id_list, offset, limit): 
     
    521524    # KO 
    522525    #### 
    523      
     526 
    524527    @cached_method 
    525528    def get_ko_by_gene(self, genes_id): 
    526529        return KeggApi.get_ko_by_gene(self, genes_id) 
    527      
     530 
    528531    @cached_method 
    529532    def get_ko_by_ko_class(self, ko_class_id): 
    530533        return KeggApi.service.get_ko_by_ko_class(self, ko_class_id) 
    531      
     534 
    532535    @cached_method 
    533536    def get_genes_by_ko_class(self, ko_class_id, org, offset, limit): 
    534         return KeggApi.get_genes_by_ko_class(self, ko_class_id, org, offset, limit) 
    535      
     537        return KeggApi.get_genes_by_ko_class(self, ko_class_id, org, offset, 
     538                                             limit) 
     539 
    536540    @cached_method 
    537541    def get_genes_by_ko(self, ko_id, org): 
    538542        return KeggApi.get_genes_by_ko(self, ko_id, org) 
    539      
     543 
    540544    ######### 
    541545    # Pathway 
     
    544548    @cached_method 
    545549    def get_genes_by_organism(self, organism, offset=None, limit=None): 
    546         return KeggApi.get_genes_by_organism(self, organism, offset=offset, limit=limit) 
    547      
     550        return KeggApi.get_genes_by_organism(self, organism, offset=offset, 
     551                                             limit=limit) 
     552 
    548553    @cached_method 
    549554    def get_number_of_genes_by_organism(self, organism): 
    550555        return KeggApi.get_number_of_genes_by_organism(self, organism) 
    551       
     556 
    552557    @cached_method 
    553558    def get_pathways_by_genes(self, gene_list): 
    554559        return KeggApi.get_pathways_by_genes(self, gene_list) 
    555      
     560 
    556561    @cached_method 
    557562    def get_pathways_by_enzymes(self, enzyme_list): 
    558563        return KeggApi.get_pathways_by_enzymes(self, enzyme_list) 
    559      
     564 
    560565    @cached_method 
    561566    def get_pathways_by_compounds(self, compound_list): 
    562567        return KeggApi.get_pathways_by_compounds(self, compound_list) 
    563      
     568 
    564569    @cached_method 
    565570    def get_pathways_by_drugs(self, drug_list): 
    566571        return KeggApi.get_pathways_by_drugs(self, drug_list) 
    567      
     572 
    568573    @cached_method 
    569574    def get_pathways_by_glycans(self, glycan_list): 
    570575        return KeggApi.get_pathways_by_glycans(self, glycan_list) 
    571      
     576 
    572577    @cached_method 
    573578    def get_pathways_by_reactions(self, reaction_list): 
    574579        return KeggApi.get_pathways_by_reactions(self, reaction_list) 
    575      
     580 
    576581    @cached_method 
    577582    def get_pathways_by_kos(self, ko_list): 
    578583        return KeggApi.get_pathways_by_kos(self, ko_list) 
    579      
     584 
    580585    @cached_method 
    581586    def get_elements_by_pathway(self, pathway_id): 
    582587        return KeggApi.get_elements_by_pathway(self, pathway_id) 
    583      
     588 
    584589    @cached_method 
    585590    def get_genes_by_pathway(self, pathway_id): 
    586591        return KeggApi.get_genes_by_pathway(self, pathway_id) 
    587      
     592 
    588593    @cached_method 
    589594    def get_enzymes_by_pathway(self, pathway_id): 
    590595        return KeggApi.get_enzymes_by_pathway(self, pathway_id) 
    591      
     596 
    592597    @cached_method 
    593598    def get_compounds_by_pathway(self, pathway_id): 
    594599        return KeggApi.get_compounds_by_pathway(self, pathway_id) 
    595      
     600 
    596601    @cached_method 
    597602    def get_drugs_by_pathway(self, pathway_id): 
    598603        return KeggApi.get_drugs_by_pathway(self, pathway_id) 
    599      
     604 
    600605    @cached_method 
    601606    def get_glycans_by_pathway(self, pathway_id): 
    602607        return KeggApi.get_glycans_by_pathway(self, pathway_id) 
    603      
     608 
    604609    @cached_method 
    605610    def get_reactions_by_pathway(self, pathway_id): 
    606611        return KeggApi.get_reactions_by_pathway(self, pathway_id) 
    607      
     612 
    608613    @cached_method 
    609614    def get_kos_by_pathway(self, pathway_id): 
  • _bioinformatics/obiKEGG/brite.py

    r1716 r1734  
    11""" 
    2 KEGG brite 
     2KEGG Brite 
    33 
    44""" 
     
    1212 
    1313from . import conf 
     14 
     15 
    1416class BriteEntry(object): 
    15     _search_re = {"ids": re.compile('(?P<ids>\[.*:.*\])'), 
    16                   "title": re.compile(r'(<[Bb]>)?(?P<title>\b[a-zA-Z0-9_/\s,;:.+=\-\[\]{}\(\)]+?)(?(1)</[Bb]>)$'), 
    17                   "links": re.compile('(?P<links><a href=".+?">.*?</a>)')} 
     17    _search_re = { 
     18        "ids": re.compile('(?P<ids>\[.*:.*\])'), 
     19        "title": re.compile(r'(<[Bb]>)?(?P<title>\b[a-zA-Z0-9_/\s,;:.+=\-\[\]{}\(\)]+?)(?(1)</[Bb]>)$'), 
     20        "links": re.compile('(?P<links><a href=".+?">.*?</a>)') 
     21    } 
     22 
    1823    def __init__(self, line): 
    1924        self.entries = [] 
     
    2833    entrys = deprecated_attribute("entrys", "entries") 
    2934 
     35 
    3036class Brite(BriteEntry): 
    3137    VERSION = "v1.0" 
    3238    BRITE_URL_FORMAT = "http://www.genome.jp/kegg-bin/download_htext?htext={brite_id}.keg&format=htext&filedir=" 
    33      
     39 
    3440    def __init__(self, brite_id, local_cache=None): 
    3541        super(Brite, self).__init__("") 
     
    3844            local_cache = conf.params["cache.path"] 
    3945        self.local_cache = local_cache 
    40          
     46 
    4147        self.load(brite_id) 
    42      
     48 
    4349    def _get_brite(self, brite_id): 
    4450        url = self.BRITE_URL_FORMAT.format(brite_id=brite_id) 
     
    4854            with open(local_filename, "wb") as f: 
    4955                f.write(brite) 
    50                  
     56 
    5157        return open(local_filename, "rb") 
    52          
     58 
    5359    def load(self, brite_id): 
    5460        lines = self._get_brite(brite_id).read().split("\n!\n")[1].splitlines() 
    55          
     61 
    5662        # TODO: Implement a proper parser 
    57          
     63 
    5864        def collect(lines, depth, collection): 
    5965            while lines: 
     
    6268                    lines.pop(0) 
    6369                elif line.startswith(depth) and len(line.strip()) > 1: 
    64                     collection.append(BriteEntry(lines.pop(0)))  
     70                    collection.append(BriteEntry(lines.pop(0))) 
    6571                elif line[0] > depth: 
    6672                    collect(lines, line[0], collection[-1].entries) 
     
    6975                else: 
    7076                    lines.pop(0) 
    71                          
    72         collect([line for line in lines if not line.startswith("#") and len(line) > 1], "A", self.entries) 
     77 
     78        collect([line for line in lines 
     79                 if not line.startswith("#") and len(line) > 1], "A", 
     80                self.entries) 
  • _bioinformatics/obiKEGG/caching.py

    r1716 r1734  
    11""" 
    22Caching framework for cached kegg api calls. 
    3   
     3 
    44""" 
    55import os 
     
    88import cPickle as pickle 
    99 
     10from contextlib import closing 
     11 
    1012from datetime import datetime, date, timedelta 
    1113from . import conf 
     14 
    1215 
    1316class Store(object): 
    1417    def __init__(self): 
    1518        self.timestamp = 0 
    16          
     19 
    1720    def open(self): 
    1821        raise NotImplementedError 
    19      
     22 
    2023    def __enter__(self): 
    2124        return self 
    22      
     25 
    2326    def __exit__(self, *args): 
    2427        pass 
     28 
    2529 
    2630class Sqlite3Store(Store, UserDict.DictMixin): 
     
    2832        self.filename = filename 
    2933        self.con = sqlite3.connect(filename) 
    30         #self.con = sqlite3.connect(":memory:") 
    31         self.con.execute(""" 
    32         CREATE TABLE IF NOT EXISTS cache  
    33             (key TEXT UNIQUE, 
    34              value TEXT 
    35             ) 
     34        self.con.execute(""" 
     35            CREATE TABLE IF NOT EXISTS cache 
     36                (key TEXT UNIQUE, 
     37                 value TEXT 
     38                ) 
    3639        """) 
    3740        self.con.execute(""" 
    38         CREATE INDEX IF NOT EXISTS cache_index 
    39         ON cache (key) 
     41            CREATE INDEX IF NOT EXISTS cache_index 
     42            ON cache (key) 
    4043        """) 
    4144        self.con.commit() 
    42          
     45 
    4346    def __getitem__(self, key): 
    4447        cur = self.con.execute(""" 
     
    4851        """, (key,)) 
    4952        r = cur.fetchall() 
    50          
     53 
    5154        if not r: 
    5255            raise KeyError(key) 
    5356        else: 
    5457            return pickle.loads(str(r[0][0])) 
    55      
     58 
    5659    def __setitem__(self, key, value): 
    5760        value = pickle.dumps(value) 
     
    6164        """, (key, value)) 
    6265        self.con.commit() 
    63          
     66 
    6467    def __delitem__(self, key): 
    6568        self.con.execute(""" 
     
    6871        """, (key,)) 
    6972        self.con.commit() 
    70          
     73 
    7174    def keys(self): 
    7275        cur = self.con.execute(""" 
     
    7578        """) 
    7679        return [str(r[0]) for r in cur.fetchall()] 
    77          
     80 
    7881    def close(self): 
    7982        pass 
    80      
    81      
     83 
     84 
    8285class DictStore(Store, UserDict.DictMixin): 
    8386    def __init__(self): 
    8487        Store.__init__(self) 
    85          
     88 
    8689    def close(self): 
    8790        pass 
    88      
    89      
    90 from functools import wraps 
    91 from contextlib import closing 
    9291 
    9392 
     
    9796        self.mtime = mtime 
    9897        self.expires = expires 
    99          
     98 
    10099_SESSION_START = datetime.now() 
    101100 
     101 
    102102class cached_wrapper(object): 
    103     """ TODO: needs documentation 
    104103    """ 
    105     def __init__(self, function, instance, class_, cache_store, last_modified=None): 
     104    TODO: needs documentation 
     105    """ 
     106    def __init__(self, function, instance, class_, cache_store, 
     107                 last_modified=None): 
    106108        self.function = function 
    107109        self.instance = instance 
     
    109111        self.cache_store = cache_store 
    110112        self.last_modified = last_modified 
    111          
     113 
    112114    def has_key(self, key): 
    113115        with closing(self.cache_store()) as store: 
    114116            return key in store 
    115      
     117 
    116118    def key_from_args(self, args, kwargs=None): 
    117119        key = self.function.__name__ + repr(args) 
    118120        return key 
    119      
     121 
    120122    def invalidate_key(self, key): 
    121123        with closing(self.cache_store()) as store: 
    122124            del store[key] 
    123              
     125 
    124126    def last_modified_from_args(self, args, kwargs=None): 
    125127        key = self.key_from_args(args, kwargs) 
    126128        if self.instance is not None: 
    127129            self.instance.last_modified(args) 
    128          
     130 
    129131    def invalidate_args(self, args): 
    130132        return self.invalidate_key(self.key_from_args(args)) 
    131          
     133 
    132134    def invalidate_all(self): 
    133135        prefix = self.key_from_args(()).rstrip(",)") 
     
    136138                if key.startswith(prefix): 
    137139                    del store[key] 
    138      
     140 
    139141    def memoize(self, args, kwargs, value, timestamp=None): 
    140142        key = self.key_from_args(args, kwargs) 
    141143        if timestamp is None: 
    142144            timestamp = datetime.now() 
    143              
     145 
    144146        with closing(self.cache_store()) as store: 
    145147            store[key] = cache_entry(value, mtime=timestamp) 
    146          
     148 
    147149    def __call__(self, *args): 
    148150        key = self.key_from_args(args) 
     
    154156                entry = store[key] 
    155157                rval = entry.value 
    156                  
     158 
    157159                if not self.is_entry_valid(entry, args): 
    158160                    valid = False 
     
    160162                rval = self.function(self.instance, *args) 
    161163                store[key] = cache_entry(rval, datetime.now(), None) 
    162          
     164 
    163165        return rval 
    164          
     166 
    165167    def min_timestamp(self, args): 
    166168        key = self.key_from_args(args) 
    167169        return datetime.fromtimestamp(0) 
    168      
     170 
    169171    def is_entry_valid(self, entry, args): 
    170172        # Need to check datetime first (it subclasses date) 
     
    176178        else: 
    177179            return False 
    178          
     180 
    179181        if self.min_timestamp(args) > mtime: 
    180182            return False 
    181          
     183 
    182184        last_modified = self.last_modified_from_args(args) 
    183          
     185 
    184186        if isinstance(last_modified, date): 
    185187            last_modified = datetime(last_modified.year, last_modified.month, 
     
    187189        elif isinstance(last_modified, basestring): 
    188190            # Could have different format 
    189             mtime = mtime.strftime("%Y %m %d %H %M %S")  
    190          
     191            mtime = mtime.strftime("%Y %m %d %H %M %S") 
     192 
    191193        elif last_modified is None: 
    192194            if conf.params["cache.invalidate"] == "always": 
     
    199201            elif conf.params["cache.invalidate"] == "weekly": 
    200202                last_modified = datetime.now() - timedelta(7) 
    201             else: # ??? 
     203            else:  # ??? 
    202204                pass 
    203205        return last_modified <= mtime 
    204          
     206 
     207 
    205208class cached_method(object): 
    206209    def __init__(self, function): 
    207210        self.function = function 
    208          
     211 
    209212    def __get__(self, instance, owner): 
    210213        if instance is not None: 
     
    212215                                  self.get_cache_store(instance, owner)) 
    213216        return self 
    214      
     217 
    215218    def get_cache_store(self, instance, owner): 
    216219        if hasattr(instance, "cache_store"): 
     
    228231                                  self.get_last_modified(instance, owner)) 
    229232        return self 
    230      
     233 
    231234    def get_last_modified(self, instance, owner): 
    232235        if hasattr(instance, "last_modified"): 
    233236            return instance.last_modified 
    234      
     237 
     238 
    235239def touch_dir(path): 
    236240    path = os.path.expanduser(path) 
    237241    if not os.path.exists(path): 
    238242        os.makedirs(path) 
    239      
     243 
     244 
    240245def clear_cache(): 
    241246    """Clear all locally cached KEGG data. 
     
    244249    path = conf.params["cache.path"] 
    245250    if os.path.realpath(path) != os.path.realpath(conf.kegg_dir): 
    246         raise Exception("Non default cache path. Please remove the contents of %r manually." % path) 
    247      
     251        raise Exception("Non default cache path. Please remove the contents " 
     252                        "of %r manually." % path) 
     253 
    248254    for cache_filename in glob.glob(os.path.join(path, "*.sqlite3")): 
    249255        os.remove(cache_filename) 
    250          
     256 
    251257    for ko_filename in glob.glob(os.path.join(path, "*.keg")): 
    252258        os.remove(ko_filename) 
    253          
     259 
    254260    for kgml_filename in glob.glob(os.path.join(path, "*.xml")): 
    255261        os.remove(kgml_filename) 
    256          
     262 
    257263    for png_filename in glob.glob(os.path.join(path, "*.png")): 
    258264        os.remove(png_filename) 
    259      
  • _bioinformatics/obiKEGG/conf.py

    r1716 r1734  
    11""" 
    2 obiKEGG2 configuration  
     2obiKEGG2 configuration 
    33 
    44mostly just caching settings 
     
    4040params = {} 
    4141 
    42 _ALL_PARAMS = \ 
    43     ["cache.path", 
    44      "cache.store", 
    45      "cache.invalidate", 
    46      "service.transport" 
    47      ] 
     42_ALL_PARAMS = [ 
     43    "cache.path", 
     44    "cache.store", 
     45    "cache.invalidate", 
     46    "service.transport" 
     47] 
     48 
    4849for p in _ALL_PARAMS: 
    4950    section, option = p.split(".") 
    5051    params[p] = parser.get(section, option) 
    51      
  • _bioinformatics/obiKEGG/databases.py

    r1733 r1734  
    396396        aliases = {} 
    397397        for entry in self.itervalues(): 
    398             aliases.update(dict.fromkeys(entry.aliases(), 
    399                                          self.org_code + ":" + entry.entry_key)) 
     398            aliases.update( 
     399                dict.fromkeys(entry.aliases(), 
     400                              self.org_code + ":" + entry.entry_key) 
     401            ) 
     402 
    400403        return aliases 
    401404 
  • _bioinformatics/obiKEGG/entry/__init__.py

    r1733 r1734  
    1111from .parser import DBGETEntryParser 
    1212 
     13 
    1314def entry_decorate(cls): 
    14     """ Decorate the DBEntry subclass with properties for acessing 
     15    """ 
     16    Decorate the DBEntry subclass with properties for accessing 
    1517    the fields through the 'DBField._convert' interface 
    16       
     18 
    1719    """ 
    1820    reserved_names_map = {"class": "class_", "def": "def_"} 
     21 
    1922    def construct_one(name): 
    2023        def get(self): 
     
    2528                return None 
    2629        return property(get, doc=name) 
    27      
     30 
    2831    def construct_multiple(name): 
    2932        def get(self): 
     
    3437                return None 
    3538        return property(get, doc=name) 
    36      
     39 
    3740    for name, field in cls.FIELDS: 
    3841        name_lower = name.lower() 
     
    4346                prop = construct_one(name) 
    4447            setattr(cls, reserved_names_map.get(name_lower, name_lower), prop) 
    45          
     48 
    4649    return cls 
    4750 
     51 
    4852class DBEntry(object): 
    49     """ A DBGET entry object. 
    5053    """ 
    51     FIELDS = [("ENTRY", fields.DBEntryField), 
    52               ] 
     54    A DBGET entry object. 
     55    """ 
     56    FIELDS = [("ENTRY", fields.DBEntryField)] 
    5357    MULTIPLE_FIELDS = [] 
    54      
     58 
    5559    def __init__(self, text=None): 
    5660        self._sections = {} 
    5761        if text is not None: 
    5862            self.parse(text) 
    59              
     63 
    6064    @property 
    6165    def entry_key(self): 
     
    6367        """ 
    6468        return self.entry.split(" ", 1)[0] 
    65      
     69 
    6670    def parse(self, text): 
    6771        parser = DBGETEntryParser() 
    6872        gen = parser.parse_string(text) 
    69         entry_start = 0 
    7073        field_constructors = dict(self.FIELDS) 
    71         sections = defaultdict(list) 
     74 
    7275        current = None 
    7376        current_subfield = None 
    7477        entry_fields = [] 
    7578        for (event, title, text) in gen: 
    76 #            print event, title, text 
    7779            if event == DBGETEntryParser.SECTION_START: 
    7880                if title in field_constructors: 
     
    9496                    new.TITLE = current.TITLE 
    9597                    current = new 
    96                      
     98 
    9799            elif event == DBGETEntryParser.SUBSECTION_END: 
    98100                current.subsections.append(current_subfield) 
     
    105107            elif event == DBGETEntryParser.ENTRY_END: 
    106108                break 
    107          
     109 
    108110        self.fields = entry_fields 
    109111        self._consolidate() 
    110          
     112 
    111113    def _consolidate(self): 
    112         """ Update mapping to field entries. 
     114        """ 
     115        Update mapping to field entries. 
    113116        """ 
    114117        registered_fields = dict(self.FIELDS) 
    115118        multiple_fields = set(self.MULTIPLE_FIELDS) 
    116          
     119 
    117120        for field in self.fields: 
    118121            title = field.TITLE 
     
    120123                import warnings 
    121124                warnings.warn("Nonregisterd field %r in %r" % \ 
    122                                 (title, type(self))) 
    123             title_lower = title.lower() 
     125                              (title, type(self))) 
     126 
    124127            if title in multiple_fields: 
    125128                if not hasattr(self, title): 
     
    128131            else: 
    129132                setattr(self, title, field) 
    130          
    131      
     133 
    132134    def __str__(self): 
    133135        return self.format() 
    134      
     136 
    135137    def format(self, section_indent=12): 
    136         return "".join(f.format(section_indent)\ 
     138        return "".join(f.format(section_indent) 
    137139                       for f in self.fields) 
    138          
     140 
    139141    def get(self, key, default=None): 
    140142        raise NotImplementedError 
    141      
     143 
    142144        f = getattr(self, key, None) 
    143145        if f is not None: 
  • _bioinformatics/obiKEGG/entry/fields.py

    r1716 r1734  
    11""" 
    2 Wrapper classes for db entry fields to support pythoninc  
     2Wrapper classes for db entry fields to support pythonic 
    33interface. 
    4    
     4 
    55""" 
    66 
     7 
    78class DBField(object): 
    8     """ Base DBGET entry field 
    9     """ 
    10     __SLOTS__ = ["text"] 
     9    """ 
     10    Base DBGET entry field 
     11    """ 
     12    __SLOTS__ = ["text"] 
     13 
    1114    def __init__(self, text): 
    1215        self.text = text 
    13          
    14     def _convert(self): 
    15         """ Convert the contents into python representation using 
    16         builtin types. 
    17           
     16 
     17    def _convert(self): 
     18        """ 
     19        Convert the contents into python representation using builtin types. 
    1820        """ 
    1921        return self.text.rstrip("\n") 
    20      
    21      
     22 
     23 
    2224class DBSimpleField(DBField): 
    23     """ Simple field (with no subsections). 
     25    """ 
     26    Simple field (with no subsections). 
    2427    """ 
    2528    __SLOTS__ = ["text"] 
    2629    # TITLE must be set in subclasses or object instances 
    2730    TITLE = None 
     31 
    2832    def __str__(self): 
    2933        return self.format() 
    30          
    31          
     34 
    3235    def format(self, section_indent=12, subsection_indent=0): 
    3336        fmt = (" " * subsection_indent) + "%-" + \ 
     
    3740        text = fmt % (self.TITLE, text) 
    3841        return text 
    39      
     42 
    4043    def _indent(self, text, section_indent=12): 
    4144        indent_str = "\n" + " " * section_indent 
    4245        nl_count = text.count("\n") 
    4346        return text.replace("\n", indent_str, nl_count - 1) 
    44      
    45      
     47 
     48 
    4649class DBEntryField(DBSimpleField): 
    47     """ ENTRY field (all entries start with this field) 
     50    """ 
     51    ENTRY field (all entries start with this field) 
    4852    """ 
    4953    __SLOTS__ = ["text"] 
    5054    TITLE = "ENTRY" 
    51      
    52      
     55 
     56 
    5357class DBNameField(DBSimpleField): 
    5458    __SLOTS__ = ["text"] 
    5559    TITLE = "NAME" 
    56      
    57      
     60 
     61 
    5862class DBDefinitionField(DBSimpleField): 
    5963    __SLOTS__ = ["text"] 
    6064    TITLE = "DEFINITION" 
    61      
    62      
     65 
     66 
    6367class DBFieldWithSubsections(DBSimpleField): 
    64     """ A field with subsections (for instance REFERENCE in genome) 
     68    """ 
     69    A field with subsections (for instance REFERENCE in genome) 
    6570    """ 
    6671    __SLOTS__ = ["text", "subsections"] 
    6772    TITLE = None 
    6873    SUBSECTIONS = None 
    69      
     74 
    7075    def __init__(self, text, subsections=None): 
    7176        self.text = text 
    7277        self.subsections = subsections or [] 
    73          
     78 
    7479    def format(self, section_indent=12, subsection_indent=2): 
    7580        text = DBSimpleField.format(self, section_indent, subsection_indent=0) 
     
    7782                       for sub in self.subsections] 
    7883        return "".join([text] + subsections) 
    79      
     84 
    8085    def _convert(self): 
    8186        my = DBSimpleField._convert(self) 
     
    8388                for s in self.subsections] 
    8489        return (my, subs) 
    85          
    86          
     90 
     91 
    8792class DBTaxonomyField(DBFieldWithSubsections): 
    8893    __SLOTS__ = ["text", "subsections"] 
    8994    TITLE = "TAXONOMY" 
    9095    SUBSECTIONS = ["LINEAGE"] 
    91      
     96 
    9297    @property 
    9398    def taxid(self): 
    9499        return DBSimpleField._convert(self).split(":")[1] 
    95      
    96      
     100 
     101 
    97102class DBDataSourceField(DBSimpleField): 
    98103    __SLOTS__ = ["text"] 
     
    104109    TITLE = "REFERENCE" 
    105110    SUBSECTIONS = ["AUTHORS", "TITLE", "JOURNAL"] 
    106      
     111 
    107112    @property 
    108113    def authors(self): 
    109114        return self.subsections[0] 
    110          
     115 
    111116    @property 
    112117    def title(self): 
    113118        return self.subsections[1] 
    114      
     119 
    115120    @property 
    116121    def journal(self): 
    117122        return self.subsections[2] 
    118      
    119      
     123 
     124 
    120125class DBDBLinks(DBSimpleField): 
    121126    __SLOTS__ = ["text"] 
    122127    TITLE = "DBLINKS" 
    123      
     128 
    124129    @property 
    125130    def links(self): 
    126131        return [tuple(s.split(": ", 1)) \ 
    127132                for s in self.text.splitlines()] 
    128          
    129     def _convert(self): 
    130         # Some dblinks can span multiple lines but are always 'indented'  
     133 
     134    def _convert(self): 
     135        # Some dblinks can span multiple lines but are always 'indented' 
    131136        links = DBSimpleField._convert(self).replace("\n ", "").splitlines() 
    132137        links = [tuple(link.split(": ", 1)) for link in links] 
     
    134139                 for key, values in links] 
    135140        return dict(links) 
    136      
    137      
     141 
     142 
    138143class DBPathway(DBSimpleField): 
    139144    __SLOTS__ = ["text"] 
    140145    TITLE = "PATHWAY" 
    141      
     146 
    142147    @property 
    143148    def pathways(self): 
    144149        return self._convert() 
    145      
     150 
    146151    def _convert(self): 
    147152        text = DBSimpleField._convert(self) 
    148153        return [line.split(" ", 1)[0] for line in text.splitlines()] 
    149      
    150      
     154 
     155 
    151156class DBAASeq(DBSimpleField): 
    152157    __SLOTS__ = ["text"] 
    153158    TITLE = "AASEQ" 
    154      
     159 
    155160    @property 
    156161    def sequence(self): 
    157162        return self.split("\n", 1)[1].replace("\n", "") 
    158      
     163 
    159164    @property 
    160165    def sequence_lenght(self): 
    161166        return int(self.text.split("\n", 1)[0]) 
    162      
     167 
    163168    def _convert(self): 
    164169        text = DBSimpleField._convert(self) 
    165170        count, seq = text.split("\n", 1) 
    166171        return seq.replace("\n", "") 
    167      
    168      
     172 
     173 
    169174class DBNTSeq(DBSimpleField): 
    170175    __SLOTS__ = ["text"] 
    171176    TITLE = "NTSEQ" 
    172      
     177 
    173178    @property 
    174179    def sequence(self): 
    175180        return self.split("\n", 1)[1].replace("\n", "") 
    176      
     181 
    177182    @property 
    178183    def sequence_lenght(self): 
    179184        return int(self.text.split("\n", 1)[0]) 
    180      
     185 
    181186    def _convert(self): 
    182187        text = DBSimpleField._convert(self) 
    183188        count, seq = text.split("\n", 1) 
    184189        return seq.replace("\n", "") 
    185      
    186      
     190 
     191 
    187192class DBPathwayMapField(DBSimpleField): 
    188193    __SLOTS__ = ["text"] 
    189194    TITLE = "PATHWAY_MAP" 
    190      
     195 
    191196    def kgml_url(self): 
    192197        return "http://www.genome.jp/kegg-bin/download?entry={0}&format=kgml".format(self.pathway_id) 
    193      
     198 
    194199    @property 
    195200    def pathway_id(self): 
    196201        return self.text.split(" ", 1)[0] 
    197      
    198      
     202 
     203 
    199204class DBGeneField(DBSimpleField): 
    200205    __SLOTS__ = ["text"] 
    201206    TITLE = "GENE" 
    202      
     207 
    203208    def _convert(self): 
    204209        text = DBSimpleField._convert(self) 
    205210        lines = text.splitlines() 
    206211        return [line.split(" ", 1)[0] for line in lines] 
    207      
     212 
     213 
    208214class DBEnzymeField(DBSimpleField): 
    209215    __SLOTS__ = ["text"] 
    210216    TITLE = "ENZYME" 
    211      
     217 
    212218    def _convert(self): 
    213219        text = DBSimpleField._convert(self) 
    214220        lines = text.splitlines() 
    215221        return lines 
    216      
     222 
     223 
    217224class DBCompoundField(DBSimpleField): 
    218225    __SLOTS__ = ["text"] 
    219226    TITLE = "COMPOUND" 
    220      
     227 
    221228    def _convert(self): 
    222229        text = DBSimpleField._convert(self) 
    223230        lines = text.splitlines() 
    224231        return [line.split(" ", 1)[0] for line in lines] 
    225      
    226      
  • _bioinformatics/obiKEGG/pathway.py

    r1733 r1734  
    88import urllib2 
    99 
    10 import xml.dom 
    1110import xml.parsers 
    1211from xml.dom import minidom 
    1312 
    1413from contextlib import closing 
     14 
     15from Orange.utils import deprecated_attribute 
    1516 
    1617from . import conf 
    1718from . import caching 
    1819from . import api 
    19  
    20 from Orange.utils import deprecated_attribute 
    2120 
    2221 
     
    3130    return wrapper 
    3231 
     32 
    3333class Pathway(object): 
    3434    KGML_URL_FORMAT = "http://www.genome.jp/kegg-bin/download?entry={pathway_id}&format=kgml" 
    35      
     35 
    3636    def __init__(self, pathway_id, local_cache=None, connection=None): 
    3737        if pathway_id.startswith("path:"): 
    3838            _, pathway_id = pathway_id.split(":", 1) 
    39              
     39 
    4040        self.pathway_id = pathway_id 
    4141        if local_cache is None: 
     
    4343        self.local_cache = local_cache 
    4444        self.connection = connection 
    45          
     45 
    4646    def cache_store(self): 
    4747        caching.touch_path(self.local_cache) 
    4848        return caching.Sqlite3Store(os.path.join(self.local_cache, 
    4949                                                 "pathway_store.sqlite3")) 
    50          
     50 
    5151    def _open_last_modified_store(self): 
    52         import shelve 
    5352        caching.touch_dir(self.local_cache) 
    5453        return caching.Sqlite3Store(os.path.join(self.local_cache, 
    5554                                                 "last_modified.sqlite3")) 
    56          
     55 
    5756    def _get_kgml(self): 
    5857        """ Return an open kgml file for the pathway. 
     
    6059        from datetime import datetime, timedelta 
    6160        valid = False 
    62         local_filename = os.path.join(self.local_cache, self.pathway_id + ".xml") 
     61        local_filename = os.path.join(self.local_cache, 
     62                                      self.pathway_id + ".xml") 
    6363        if os.path.exists(local_filename): 
    6464            mtime = os.stat(local_filename).st_mtime 
     
    7575            else: 
    7676                valid = False 
    77          
     77 
    7878        if not valid: 
    7979            url = self.KGML_URL_FORMAT.format(pathway_id=self.pathway_id) 
    8080            s = urllib2.urlopen(url) 
    8181            contents = s.read() 
    82              
     82 
    8383            with open(local_filename, "wb") as f: 
    8484                f.write(contents) 
    85                  
     85 
    8686        return open(local_filename, "rb") 
    87      
     87 
    8888    def _get_image_filename(self): 
    8989        """ Return a filename of a local copy of the pathway image 
     
    9191        # TODO: keep-alive (using httplib if it supports it) 
    9292        # better to move all code to use requests package 
    93          
     93 
    9494        url = str(self.image) 
    95          
    96         local_filename = os.path.join(self.local_cache, self.pathway_id + ".png") 
    97          
     95 
     96        local_filename = os.path.join(self.local_cache, 
     97                                      self.pathway_id + ".png") 
     98 
    9899        if not os.path.exists(local_filename): 
    99100            response = urllib2.urlopen(url) 
     
    102103        else: 
    103104            request = urllib2.Request(url) 
    104             modified_cache = os.path.join(self.local_cache, "http-last-modified-cache.store") 
    105105            with closing(self._open_last_modified_store()) as store: 
    106106                modified_since = store.get(url, None) 
    107                  
     107 
    108108            request.add_header("If-Modified-Since", modified_since) 
    109109            try: 
     
    116116            modified_since = response.headers.get("last-modified") 
    117117            image = response.read() 
    118                  
     118 
    119119        with open(local_filename, "wb") as f: 
    120120            f.write(image) 
    121              
     121 
    122122        with closing(self._open_last_modified_store()) as store: 
    123123            store[url] = modified_since 
    124              
    125         return local_filename  
    126          
     124 
     125        return local_filename 
     126 
    127127    def _local_kgml_filename(self): 
    128128        """ Return the local kgml xml filename for the pathway. 
    129129        """ 
    130         local_filename = os.path.join(self.local_cache, self.pathway_id + ".xml") 
     130        local_filename = os.path.join(self.local_cache, 
     131                                      self.pathway_id + ".xml") 
    131132        return local_filename 
    132          
     133 
    133134    class entry(object): 
    134135        def __init__(self, dom_element): 
     
    138139            self.graphics = dict(dom_element.getElementsByTagName("graphics")[0].attributes.items()) 
    139140            self.components = [node.getAttribute("id") for node in dom_element.getElementsByTagName("component")] 
    140              
     141 
    141142    class reaction(object): 
    142143        def __init__(self, dom_element): 
     
    144145            self.substrates = [node.getAttribute("name") for node in dom_element.getElementsByTagName("substrate")] 
    145146            self.products = [node.getAttribute("name") for node in dom_element.getElementsByTagName("product")] 
    146              
     147 
    147148    class relation(object): 
    148149        def __init__(self, dom_element): 
    149150            self.__dict__.update(dom_element.attributes.items()) 
    150151            self.subtypes = [node.attributes.items() for node in dom_element.getElementsByTagName("subtype")] 
    151          
     152 
    152153    @cached_method 
    153154    def pathway_attributes(self): 
    154155        return dict(self.pathway_dom().attributes.items()) 
    155      
     156 
    156157    @property 
    157158    def name(self): 
    158159        return self.pathway_attributes().get("name") 
    159      
     160 
    160161    @property 
    161162    def org(self): 
    162163        return self.pathway_attributes().get("org") 
    163      
     164 
    164165    @property 
    165166    def number(self): 
    166167        return self.pathway_attributes().get("number") 
    167      
    168     @property     
     168 
     169    @property 
    169170    def title(self): 
    170171        return self.pathway_attributes().get("title") 
    171      
     172 
    172173    @property 
    173174    def image(self): 
    174175        return self.pathway_attributes().get("image") 
    175      
     176 
    176177    @property 
    177178    def link(self): 
    178179        return self.pathway_attributes().get("link") 
    179      
     180 
    180181    @cached_method 
    181182    def pathway_dom(self): 
     
    185186            # TODO: Should delete the cached xml file. 
    186187            return None 
    187      
     188 
    188189    @cached_method 
    189190    def entries(self): 
     
    193194        else: 
    194195            return [] 
    195      
     196 
    196197    entrys = deprecated_attribute("entrys", "entries") 
    197      
     198 
    198199    @cached_method 
    199200    def reactions(self): 
     
    203204        else: 
    204205            return [] 
    205      
     206 
    206207    @cached_method 
    207208    def relations(self): 
     
    211212        else: 
    212213            return [] 
    213      
     214 
    214215    def __iter__(self): 
    215216        """ Iterate over all elements in the pathway 
    216217        """ 
    217218        return iter(self.all_elements()) 
    218      
     219 
    219220    def __contains__(self, element): 
    220221        """ Retrurn true if element in the pathway 
    221222        """ 
    222223        return element in self.all_elements() 
    223      
     224 
    224225    @classmethod 
    225226    def split_pathway_id(cls, id): 
    226227        path, id = id.split(":") if ":" in id else ("path", id) 
    227228        org, id = id[:-5], id[-5:] 
    228         return path, org, id   
    229      
     229        return path, org, id 
     230 
    230231    @cached_method 
    231232    def all_elements(self): 
    232233        """ Return all elements 
    233234        """ 
    234         return reduce(list.__add__, [self.genes(), self.compounds(), self.enzmes(), self.reactions()], []) 
    235      
     235        return reduce(list.__add__, 
     236                      [self.genes(), self.compounds(), 
     237                       self.enzmes(), self.reactions()], 
     238                      []) 
     239 
    236240    def _get_entries_by_type(self, type): 
    237         return sorted(reduce(set.union, [entry.name.split() for entry in self.entries() if entry.type == type], set())) 
    238      
     241        return sorted(reduce(set.union, 
     242                             [entry.name.split() for entry in self.entries() 
     243                              if entry.type == type], 
     244                             set())) 
     245 
    239246    @cached_method 
    240247    def genes(self): 
     
    242249        """ 
    243250        return self._get_entries_by_type("gene") 
    244      
     251 
    245252    @cached_method 
    246253    def compounds(self): 
     
    248255        """ 
    249256        return self._get_entries_by_type("compound") 
    250      
     257 
    251258    @cached_method 
    252259    def enzymes(self): 
     
    254261        """ 
    255262        return self._get_entries_by_type("enzyme") 
    256      
     263 
    257264    @cached_method 
    258265    def orthologs(self): 
     
    260267        """ 
    261268        return self._get_entries_by_type("ortholog") 
    262      
     269 
    263270    @cached_method 
    264271    def maps(self): 
     
    266273        """ 
    267274        return self._get_entries_by_type("map") 
    268      
     275 
    269276    @cached_method 
    270277    def groups(self): 
     
    272279        """ 
    273280        return self._get_entries_by_type("ortholog") 
    274      
     281 
    275282    def get_image(self): 
    276283        """ Return an image of the pathway 
  • _bioinformatics/obiKEGG/types.py

    r1733 r1734  
    144144                "type", 
    145145                ]) 
    146  
Note: See TracChangeset for help on using the changeset viewer.