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