wrw/util.py

   1 from __future__ import with_statement
   2 import inspect
   3 import req, dispatch, session, form
   4
   5 def wsgiwrap(callable):
   6     def wrapper(env, startreq):
   7         return dispatch.handle(req.origrequest(env), startreq, callable)
   8     return wrapper
   9
  10 def formparams(callable):
  11     def wrapper(req):
  12         data = form.formdata(req)
  13         spec = inspect.getargspec(callable)
  14         args = dict(data.items())
  15         args["req"] = req
  16         if not spec[2]:
  17             for arg in list(args):
  18                 if arg not in spec[0]:
  19                     del args[arg]
  20         return callable(**args)
  21     return wrapper
  22
  23 def persession(data = None):
  24     def dec(callable):
  25         def wrapper(req):
  26             sess = session.get(req)
  27             if callable not in sess:
  28                 if data is None:
  29                     sess[callable] = callable()
  30                 else:
  31                     if data not in sess:
  32                         sess[data] = data()
  33                     sess[callable] = callable(data)
  34             return sess[callable].handle(req)
  35         return wrapper
  36     return dec
  37
  38 class sessiondata(object):
  39     @classmethod
  40     def get(cls, req, create = True):
  41         sess = cls.sessdb().get(req)
  42         with sess.lock:
  43             try:
  44                 return sess[cls]
  45             except KeyError:
  46                 if not create:
  47                     return None
  48                 ret = cls(req, sess)
  49                 sess[cls] = ret
  50                 return ret
  51
  52     @classmethod
  53     def sessdb(cls):
  54         return session.default.val
  55
  56 class autodirty(sessiondata):
  57     @classmethod
  58     def get(cls, req):
  59         ret = super(autodirty, cls).get(req)
  60         if "_is_dirty" not in ret.__dict__:
  61             ret.__dict__["_is_dirty"] = False
  62         return ret
  63
  64     def sessfrozen(self):
  65         self.__dict__["_is_dirty"] = False
  66
  67     def sessdirty(self):
  68         return self._is_dirty
  69
  70     def __setattr__(self, name, value):
  71         super(autodirty, self).__setattr__(name, value)
  72         if "_is_dirty" in self.__dict__:
  73             self.__dict__["_is_dirty"] = True
  74
  75     def __delattr__(self, name):
  76         super(autodirty, self).__delattr__(name, value)
  77         if "_is_dirty" in self.__dict__:
  78             self.__dict__["_is_dirty"] = True
  79
  80 class manudirty(object):
  81     def __init__(self, *args, **kwargs):
  82         super(manudirty, self).__init__(*args, **kwargs)
  83         self.__dirty = False
  84
  85     def sessfrozen(self):
  86         self.__dirty = False
  87
  88     def sessdirty(self):
  89         return self.__dirty
  90
  91     def dirty(self):
  92         self.__dirty = True
  93
  94 class specslot(object):
  95     __slots__ = ["nm", "idx", "dirty"]
  96     unbound = object()
  97
  98     def __init__(self, nm, idx, dirty):
  99         self.nm = nm
 100         self.idx = idx
 101         self.dirty = dirty
 102
 103     @staticmethod
 104     def slist(ins):
 105         # Avoid calling __getattribute__
 106         return specdirty.__sslots__.__get__(ins, type(ins))
 107
 108     def __get__(self, ins, cls):
 109         val = self.slist(ins)[self.idx]
 110         if val is specslot.unbound:
 111             raise AttributeError("specslot %r is unbound" % self.nm)
 112         return val
 113
 114     def __set__(self, ins, val):
 115         self.slist(ins)[self.idx] = val
 116         if self.dirty:
 117             ins.dirty()
 118
 119     def __delete__(self, ins):
 120         self.slist(ins)[self.idx] = specslot.unbound
 121         ins.dirty()
 122
 123 class specclass(type):
 124     def __init__(self, name, bases, tdict):
 125         super(specclass, self).__init__(name, bases, tdict)
 126         sslots = set()
 127         dslots = set()
 128         for cls in self.__mro__:
 129             css = cls.__dict__.get("__saveslots__", ())
 130             sslots.update(css)
 131             dslots.update(cls.__dict__.get("__dirtyslots__", css))
 132         self.__sslots_l__ = list(sslots)
 133         self.__sslots_a__ = list(sslots | dslots)
 134         for i, slot in enumerate(self.__sslots_a__):
 135             setattr(self, slot, specslot(slot, i, slot in dslots))
 136
 137 class specdirty(sessiondata):
 138     __metaclass__ = specclass
 139     __slots__ = ["session", "__sslots__", "_is_dirty"]
 140
 141     def __specinit__(self):
 142         pass
 143
 144     @staticmethod
 145     def __new__(cls, req, sess):
 146         self = super(specdirty, cls).__new__(cls)
 147         self.session = sess
 148         self.__sslots__ = [specslot.unbound] * len(cls.__sslots_a__)
 149         self.__specinit__()
 150         self._is_dirty = False
 151         return self
 152
 153     def __getnewargs__(self):
 154         return (None, self.session)
 155
 156     def dirty(self):
 157         self._is_dirty = True
 158
 159     def sessfrozen(self):
 160         self._is_dirty = False
 161
 162     def sessdirty(self):
 163         return self._is_dirty
 164
 165     def __getstate__(self):
 166         ret = {}
 167         for nm, val in zip(type(self).__sslots_a__, specslot.slist(self)):
 168             if val is specslot.unbound:
 169                 ret[nm] = False, None
 170             else:
 171                 ret[nm] = True, val
 172         return ret
 173
 174     def __setstate__(self, st):
 175         ss = specslot.slist(self)
 176         for i, nm in enumerate(type(self).__sslots_a__):
 177             bound, val = st.pop(nm, (False, None))
 178             if not bound:
 179                 ss[i] = specslot.unbound
 180             else:
 181                 ss[i] = val