wrw/util.py

   1 import inspect, math
   2 from . import req, dispatch, session, form, resp, proto
   3
   4 def wsgiwrap(callable):
   5     def wrapper(env, startreq):
   6         return dispatch.handleenv(env, startreq, callable)
   7     wrapper.__wrapped__ = callable
   8     return wrapper
   9
  10 def stringwrap(charset):
  11     def dec(callable):
  12         def wrapper(*args, **kwargs):
  13             bk = callable(*args, **kwargs)
  14             for string in bk:
  15                 yield string.encode(charset)
  16         return wrapper
  17     return dec
  18
  19 def formparams(callable):
  20     spec = inspect.getargspec(callable)
  21     def wrapper(req):
  22         data = form.formdata(req)
  23         args = dict(data.items())
  24         args["req"] = req
  25         if not spec.keywords:
  26             for arg in list(args):
  27                 if arg not in spec.args:
  28                     del args[arg]
  29         for i in range(len(spec.args) - (len(spec.defaults) if spec.defaults else 0)):
  30             if spec.args[i] not in args:
  31                 raise resp.httperror(400, "Missing parameter", ("The query parameter `", resp.h.code(spec.args[i]), "' is required but not supplied."))
  32         return callable(**args)
  33     wrapper.__wrapped__ = callable
  34     return wrapper
  35
  36 class funplex(object):
  37     def __init__(self, *funs, **nfuns):
  38         self.dir = {}
  39         self.dir.update(((self.unwrap(fun).__name__, fun) for fun in funs))
  40         self.dir.update(nfuns)
  41
  42     @staticmethod
  43     def unwrap(fun):
  44         while hasattr(fun, "__wrapped__"):
  45             fun = fun.__wrapped__
  46         return fun
  47
  48     def __call__(self, req):
  49         if req.pathinfo == "":
  50             raise resp.redirect(req.uriname + "/")
  51         if req.pathinfo[:1] != "/":
  52             raise resp.notfound()
  53         p = req.pathinfo[1:]
  54         if p == "":
  55             p = "__index__"
  56             bi = 1
  57         else:
  58             p = p.partition("/")[0]
  59             bi = len(p) + 1
  60         if p in self.dir:
  61             return self.dir[p](req.shift(bi))
  62         raise resp.notfound()
  63
  64     def add(self, fun):
  65         self.dir[self.unwrap(fun).__name__] = fun
  66         return fun
  67
  68     def name(self, name):
  69         def dec(fun):
  70             self.dir[name] = fun
  71             return fun
  72         return dec
  73
  74 def persession(data=None):
  75     def dec(callable):
  76         def wrapper(req):
  77             sess = session.get(req)
  78             if callable not in sess:
  79                 if data is None:
  80                     sess[callable] = callable()
  81                 else:
  82                     if data not in sess:
  83                         sess[data] = data()
  84                     sess[callable] = callable(data)
  85             return sess[callable].handle(req)
  86         wrapper.__wrapped__ = callable
  87         return wrapper
  88     return dec
  89
  90 class preiter(object):
  91     __slots__ = ["bk", "bki", "_next"]
  92     end = object()
  93     def __init__(self, real):
  94         self.bk = real
  95         self.bki = iter(real)
  96         self._next = None
  97         self.__next__()
  98
  99     def __iter__(self):
 100         return self
 101
 102     def __next__(self):
 103         if self._next is self.end:
 104             raise StopIteration()
 105         ret = self._next
 106         try:
 107             self._next = next(self.bki)
 108         except StopIteration:
 109             self._next = self.end
 110         return ret
 111
 112     def close(self):
 113         if hasattr(self.bk, "close"):
 114             self.bk.close()
 115
 116 def pregen(callable):
 117     def wrapper(*args, **kwargs):
 118         return preiter(callable(*args, **kwargs))
 119     wrapper.__wrapped__ = callable
 120     return wrapper
 121
 122 class sessiondata(object):
 123     @classmethod
 124     def get(cls, req, create=True):
 125         sess = cls.sessdb().get(req)
 126         with sess.lock:
 127             try:
 128                 return sess[cls]
 129             except KeyError:
 130                 if not create:
 131                     return None
 132                 ret = cls(req, sess)
 133                 sess[cls] = ret
 134                 return ret
 135
 136     @classmethod
 137     def sessdb(cls):
 138         return session.default.val
 139
 140 class autodirty(sessiondata):
 141     @classmethod
 142     def get(cls, req):
 143         ret = super().get(req)
 144         if "_is_dirty" not in ret.__dict__:
 145             ret.__dict__["_is_dirty"] = False
 146         return ret
 147
 148     def sessfrozen(self):
 149         self.__dict__["_is_dirty"] = False
 150
 151     def sessdirty(self):
 152         return self._is_dirty
 153
 154     def __setattr__(self, name, value):
 155         super().__setattr__(name, value)
 156         if "_is_dirty" in self.__dict__:
 157             self.__dict__["_is_dirty"] = True
 158
 159     def __delattr__(self, name):
 160         super().__delattr__(name, value)
 161         if "_is_dirty" in self.__dict__:
 162             self.__dict__["_is_dirty"] = True
 163
 164 class manudirty(object):
 165     def __init__(self, *args, **kwargs):
 166         super().__init__(*args, **kwargs)
 167         self.__dirty = False
 168
 169     def sessfrozen(self):
 170         self.__dirty = False
 171
 172     def sessdirty(self):
 173         return self.__dirty
 174
 175     def dirty(self):
 176         self.__dirty = True
 177
 178 class specslot(object):
 179     __slots__ = ["nm", "idx", "dirty"]
 180     unbound = object()
 181
 182     def __init__(self, nm, idx, dirty):
 183         self.nm = nm
 184         self.idx = idx
 185         self.dirty = dirty
 186
 187     @staticmethod
 188     def slist(ins):
 189         # Avoid calling __getattribute__
 190         return specdirty.__sslots__.__get__(ins, type(ins))
 191
 192     def __get__(self, ins, cls):
 193         val = self.slist(ins)[self.idx]
 194         if val is specslot.unbound:
 195             raise AttributeError("specslot %r is unbound" % self.nm)
 196         return val
 197
 198     def __set__(self, ins, val):
 199         self.slist(ins)[self.idx] = val
 200         if self.dirty:
 201             ins.dirty()
 202
 203     def __delete__(self, ins):
 204         self.slist(ins)[self.idx] = specslot.unbound
 205         ins.dirty()
 206
 207 class specclass(type):
 208     def __init__(self, name, bases, tdict):
 209         super().__init__(name, bases, tdict)
 210         sslots = set()
 211         dslots = set()
 212         for cls in self.__mro__:
 213             css = cls.__dict__.get("__saveslots__", ())
 214             sslots.update(css)
 215             dslots.update(cls.__dict__.get("__dirtyslots__", css))
 216         self.__sslots_l__ = list(sslots)
 217         self.__sslots_a__ = list(sslots | dslots)
 218         for i, slot in enumerate(self.__sslots_a__):
 219             setattr(self, slot, specslot(slot, i, slot in dslots))
 220
 221 class specdirty(sessiondata, metaclass=specclass):
 222     __slots__ = ["session", "__sslots__", "_is_dirty"]
 223
 224     def __specinit__(self):
 225         pass
 226
 227     @staticmethod
 228     def __new__(cls, req, sess):
 229         self = super().__new__(cls)
 230         self.session = sess
 231         self.__sslots__ = [specslot.unbound] * len(cls.__sslots_a__)
 232         self.__specinit__()
 233         self._is_dirty = False
 234         return self
 235
 236     def __getnewargs__(self):
 237         return (None, self.session)
 238
 239     def dirty(self):
 240         self._is_dirty = True
 241
 242     def sessfrozen(self):
 243         self._is_dirty = False
 244
 245     def sessdirty(self):
 246         return self._is_dirty
 247
 248     def __getstate__(self):
 249         ret = {}
 250         for nm, val in zip(type(self).__sslots_a__, specslot.slist(self)):
 251             if val is specslot.unbound:
 252                 ret[nm] = False, None
 253             else:
 254                 ret[nm] = True, val
 255         return ret
 256
 257     def __setstate__(self, st):
 258         ss = specslot.slist(self)
 259         for i, nm in enumerate(type(self).__sslots_a__):
 260             bound, val = st.pop(nm, (False, None))
 261             if not bound:
 262                 ss[i] = specslot.unbound
 263             else:
 264                 ss[i] = val
 265
 266 def datecheck(req, mtime):
 267     if "If-Modified-Since" in req.ihead:
 268         rtime = proto.phttpdate(req.ihead["If-Modified-Since"])
 269         if rtime >= math.floor(mtime):
 270             raise resp.unmodified()
 271     req.ohead["Last-Modified"] = proto.httpdate(mtime)