Maximum CD 2009 June/maximum-cd-2009-06.iso/DiscContents/digsby_setup.exe/lib/util/cacheable.pyo

Python Compiled Bytecode | 2009-02-26 | 11.0 KB | 412 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

from __future__ import with_statement
__metaclass__ = type
from primitives import autoassign, Storage as S
from introspect import base_classes
import stdpaths
import httplib2
from logging import getLogger
log = getLogger('cacheable')
info = log.info
from os.path import split as pathsplit, exists as pathexists, join as pathjoin
import os
import sys
import traceback
from zlib import compress, decompress
import cPickle
import simplejson

try:
    sentinel
except NameError:

    class Sentinel(object):

        def __repr__(self):
            return '<Sentinel (%r backup) %#x>' % (__file__, id(self))


    sentinel = Sentinel()

_cacheattr = '__cached'

def save_cache_object(name, obj, user = False, json = False):
    dumps = None if json else cPickle.dumps
    croot = get_cache_root(user)
    if not croot.exists():
        croot.makedirs()


    try:
        f = _[2]
        f.write(compress(dumps(obj)))
    finally:
        pass



def load_cache_object(name, user = False, json = False):
    p = get_cache_root(user) / name
    if not p.isfile():
        return None

    loads = None if json else cPickle.loads

    try:
        f = _[2]
        return loads(decompress(f.read()))
    finally:
        pass


cache_formats = dict(json = (simplejson.dumps, simplejson.loads), pickle = (cPickle.dumps, simplejson.loads))

class DiskCache(object):

    def __init__(self, name, user = True, format = 'json', validator = None):
        (self.dumps, self.loads) = cache_formats[format]
        self.filename = get_cache_root(user) / name
        self.format = format
        self.validator = validator


    def exists(self):

        try:
            return self.filename.isfile()
        except Exception:
            traceback.print_exc()
            return False



    def safe_load(self, default_func):

        try:
            if self.exists():
                return self.load()
        except Exception:
            traceback.print_exc()

        return default_func()


    def load(self):

        try:
            f = _[2]
            obj = self.loads(decompress(f.read()))
        finally:
            pass

        if self.validator is not None:
            obj = self.validator(obj)

        return obj


    def save(self, obj):

        try:

            try:
                f = _[2]
                f.write(compress(self.dumps(obj)))
            finally:
                pass

        except Exception:
            traceback.print_exc()



    def __repr__(self):
        return '<%s at %r, format=%s>' % (self.__class__.__name__, self.filename, self.format)



def get_cache_root(user = False):
    root = stdpaths.userlocaldata / 'cache'
    if user:
        profile = profile
        import common
        if profile:
            name = profile.username
        else:
            name = ''
        root = root / (name + '_cache')

    return root


def get_obj_cache_path(obj, user = False):
    ocp = getattr(obj, 'cache_path', '')
    if not ocp:
        import warnings
        warnings.warn('%r does not have a cache path, you really should give it one.' % obj)

    return get_cache_root(user) / ocp


def clear_file_cache(obj, user = False):
    return os.remove(get_obj_cache_path(obj, user = user))


def load_file_cache(obj, user = False):
    cache_path = get_obj_cache_path(obj, user)
    if not pathexists(cache_path):
        return None


    try:
        f = _[2]
        return f.read()
    finally:
        pass



def save_file_cache(obj, data, user = False):
    cache_path = get_obj_cache_path(obj, user)
    cache_head = pathsplit(cache_path)[0]
    if not pathexists(cache_head):
        os.makedirs(cache_head)


    try:
        f = _[2]
        f.write(data)
    finally:
        pass



class cproperty:

    def __init__(self, default = sentinel, box = None, unbox = None, user = False):
        self.default = default
        if box is not None:
            self.box = box
            self.unbox = unbox
        else:
            self.box = self.unbox = (lambda o: o)
        self.usermode = user


    def load_cache(self, obj):
        data = load_file_cache(obj, self.usermode)
        if hasattr(obj, 'cache_crypt'):
            if data is not None:

                try:
                    data = obj.cache_crypt[1](data)
                except Exception:
                    e = None
                    traceback.print_exc()
                    print repr(data), repr(e)
                except:
                    None<EXCEPTION MATCH>Exception


            None<EXCEPTION MATCH>Exception


        try:
            boxed = None if data is not None else { }
        except Exception:
            e = None
            traceback.print_exc()
            boxed = { }

        cache = { }
        error = False
        for k, v in boxed.iteritems():

            try:
                cache.update({
                    k: self.cacheprop(obj, k).unbox(v) })
            continue
            except Exception:
                traceback.print_exc()
                error = True
                continue



        if error:
            log.warning('error retreiving cache for %s', obj)

        setattr(obj, _cacheattr, cache)
        return cache


    def save_cache(self, obj):
        cache = getattr(obj, _cacheattr)
        boxed = (None, dict)((lambda .0: for k, v in .0:
(k, self.cacheprop(obj, k).box(v)))(cache.iteritems()))
        compressed = compress(cPickle.dumps(boxed))
        if hasattr(obj, 'cache_crypt'):
            compressed = obj.cache_crypt[0](compressed)

        save_file_cache(obj, compressed, self.usermode)


    def __get__(self, obj, objtype):
        cache = getattr(obj, _cacheattr, sentinel)
        if cache is sentinel:

            try:
                cache = self.load_cache(obj)
            except Exception:
                traceback.print_exc()
                msg = 'error when getting cached attribute %s of %r' % (self.name(objtype), obj)
                print >>sys.stderr, msg
                cache = { }
            except:
                None<EXCEPTION MATCH>Exception


        None<EXCEPTION MATCH>Exception
        name = self.name(objtype)

        try:
            val = cache[name]
        except KeyError:

            try:
                val = self.default()
            except (AttributeError, TypeError):
                val = self.default

            if val is not sentinel:
                cache[name] = val

        except:
            val is not sentinel

        if val is sentinel:
            raise AttributeError

        return val


    def name(self, objtype):

        try:
            return self._name
        except:
            bases = [
                objtype] + base_classes(objtype)
            for clz in bases:
                for k, v in clz.__dict__.iteritems():
                    if v is self:
                        self._name = k
                        return k
                        continue



        raise AssertionError, str(bases)


    def cacheprop(cls, objtype, name):
        objtype = objtype.__class__

        try:
            return vars(objtype)[name]
        except:
            bases = base_classes(objtype)
            for base in bases:

                try:
                    return vars(base)[name]
                continue
                except KeyError:
                    continue




        raise AssertionError, 'cannot find %s in %s' % (name, objtype)

    cacheprop = classmethod(cacheprop)

    def __set__(self, obj, value):
        cache = getattr(obj, _cacheattr, sentinel)
        if cache is sentinel:

            try:
                cache = self.load_cache(obj)
            except Exception:
                e = None
                traceback.print_exc()
                print >>sys.stderr, 'error loading cache for %r while setting value %s' % (obj, self.name(obj.__class__))
                cache = { }
            except:
                None<EXCEPTION MATCH>Exception


        None<EXCEPTION MATCH>Exception
        cache[self.name(obj.__class__)] = value

        try:
            self.save_cache(obj)
        except Exception:
            e = None
            traceback.print_exc()
            print >>sys.stderr, 'error saving cache for %r while setting value %s' % (obj, self.name(obj.__class__))



    def __delete__(self, obj):
        self.fdel(obj)



class Buddy:

    def __init__(self, name, protocol):
        autoassign(self, locals())


    def cache_path(self):
        proto = self.protocol
        return pathjoin(proto.name, proto.username, self.name) + '.dat'

    cache_path = property(cache_path)
    remote_alias = cproperty(5)


def urlcacheopen(url, *a, **k):
    http = httplib2.Http(cache = unicode(get_cache_root() / 'webcache'))
    (resp, content) = http.request(url, *a, **k)
    log.debug('%s for %s', resp.status, url)
    return (resp, content)

if __name__ == '__main__':
    import wx
    app = wx.PySimpleApp()
    b = Buddy('Joe', S(name = 'aim', username = 'digsby01'))
    print b.remote_alias
    b.remote_alias = 'network alias'

    class Foo(dict):
        pass


    class TestAble(object):

        def cache_path(self):
            return 'testable.dat'

        cache_path = property(cache_path)
        uids = cproperty(Foo, box = dict, unbox = Foo)

    t = TestAble()
    print t.uids
    t.uids[0] = 'sdfasd'
    print t.uids