Changeset 1734:91d14dd2cf0e in orange-bioinformatics for _bioinformatics/obiKEGG/caching.py


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

obiKEGG code style fixes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _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      
Note: See TracChangeset for help on using the changeset viewer.