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