X-Git-Url: http://dolda2000.com/gitweb/?a=blobdiff_plain;f=wrw%2Futil.py;h=eb2768319804b40caa2f78765fbb78661263187c;hb=8fec8547c47c0452333972f554f328d0c8e61be2;hp=c2af5aab447b3c3dc187a39c1c2b7b743de441be;hpb=5b35322cd15175024d9a9ad08ddbd0e50a18f1e2;p=wrw.git diff --git a/wrw/util.py b/wrw/util.py index c2af5aa..eb27683 100644 --- a/wrw/util.py +++ b/wrw/util.py @@ -1,11 +1,20 @@ import inspect -import req, dispatch, session, form +from . import req, dispatch, session, form, resp def wsgiwrap(callable): def wrapper(env, startreq): - return dispatch.handle(req.origrequest(env), startreq, callable) + return dispatch.handleenv(env, startreq, callable) return wrapper +def stringwrap(charset): + def dec(callable): + def wrapper(*args, **kwargs): + bk = callable(*args, **kwargs) + for string in bk: + yield string.encode(charset) + return wrapper + return dec + def formparams(callable): def wrapper(req): data = form.formdata(req) @@ -16,9 +25,33 @@ def formparams(callable): for arg in list(args): if arg not in spec.args: del args[arg] + for i in range(len(spec.args) - len(spec.defaults)): + if spec.args[i] not in args: + raise resp.httperror(400, "Missing parameter", ("The query parameter `", resp.h.code(spec.args[i]), "' is required but not supplied.")) return callable(**args) return wrapper +def funplex(*funs, **nfuns): + dir = {} + dir.update(((fun.__name__, fun) for fun in funs)) + dir.update(nfuns) + def handler(req): + if req.pathinfo == "": + raise resp.redirect(req.uriname + "/") + if req.pathinfo[:1] != "/": + raise resp.notfound() + p = req.pathinfo[1:] + if p == "": + p = "__index__" + bi = 1 + else: + p = p.partition("/")[0] + bi = len(p) + 1 + if p in dir: + return dir[p](req.shift(bi)) + raise resp.notfound() + return handler + def persession(data = None): def dec(callable): def wrapper(req): @@ -34,6 +67,37 @@ def persession(data = None): return wrapper return dec +class preiter(object): + __slots__ = ["bk", "bki", "_next"] + end = object() + def __init__(self, real): + self.bk = real + self.bki = iter(real) + self._next = None + self.__next__() + + def __iter__(self): + return self + + def __next__(self): + if self._next is self.end: + raise StopIteration() + ret = self._next + try: + self._next = next(self.bki) + except StopIteration: + self._next = self.end + return ret + + def close(self): + if hasattr(self.bk, "close"): + self.bk.close() + +def pregen(callable): + def wrapper(*args, **kwargs): + return preiter(callable(*args, **kwargs)) + return wrapper + class sessiondata(object): @classmethod def get(cls, req, create = True): @@ -55,7 +119,7 @@ class sessiondata(object): class autodirty(sessiondata): @classmethod def get(cls, req): - ret = super(autodirty, cls).get(req) + ret = super().get(req) if "_is_dirty" not in ret.__dict__: ret.__dict__["_is_dirty"] = False return ret @@ -67,18 +131,18 @@ class autodirty(sessiondata): return self._is_dirty def __setattr__(self, name, value): - super(autodirty, self).__setattr__(name, value) + super().__setattr__(name, value) if "_is_dirty" in self.__dict__: self.__dict__["_is_dirty"] = True def __delattr__(self, name): - super(autodirty, self).__delattr__(name, value) + super().__delattr__(name, value) if "_is_dirty" in self.__dict__: self.__dict__["_is_dirty"] = True class manudirty(object): def __init__(self, *args, **kwargs): - super(manudirty, self).__init__(*args, **kwargs) + super().__init__(*args, **kwargs) self.__dirty = False def sessfrozen(self): @@ -89,3 +153,91 @@ class manudirty(object): def dirty(self): self.__dirty = True + +class specslot(object): + __slots__ = ["nm", "idx", "dirty"] + unbound = object() + + def __init__(self, nm, idx, dirty): + self.nm = nm + self.idx = idx + self.dirty = dirty + + @staticmethod + def slist(ins): + # Avoid calling __getattribute__ + return specdirty.__sslots__.__get__(ins, type(ins)) + + def __get__(self, ins, cls): + val = self.slist(ins)[self.idx] + if val is specslot.unbound: + raise AttributeError("specslot %r is unbound" % self.nm) + return val + + def __set__(self, ins, val): + self.slist(ins)[self.idx] = val + if self.dirty: + ins.dirty() + + def __delete__(self, ins): + self.slist(ins)[self.idx] = specslot.unbound + ins.dirty() + +class specclass(type): + def __init__(self, name, bases, tdict): + super().__init__(name, bases, tdict) + sslots = set() + dslots = set() + for cls in self.__mro__: + css = cls.__dict__.get("__saveslots__", ()) + sslots.update(css) + dslots.update(cls.__dict__.get("__dirtyslots__", css)) + self.__sslots_l__ = list(sslots) + self.__sslots_a__ = list(sslots | dslots) + for i, slot in enumerate(self.__sslots_a__): + setattr(self, slot, specslot(slot, i, slot in dslots)) + +class specdirty(sessiondata, metaclass=specclass): + __slots__ = ["session", "__sslots__", "_is_dirty"] + + def __specinit__(self): + pass + + @staticmethod + def __new__(cls, req, sess): + self = super().__new__(cls) + self.session = sess + self.__sslots__ = [specslot.unbound] * len(cls.__sslots_a__) + self.__specinit__() + self._is_dirty = False + return self + + def __getnewargs__(self): + return (None, self.session) + + def dirty(self): + self._is_dirty = True + + def sessfrozen(self): + self._is_dirty = False + + def sessdirty(self): + return self._is_dirty + + def __getstate__(self): + ret = {} + for nm, val in zip(type(self).__sslots_a__, specslot.slist(self)): + if val is specslot.unbound: + ret[nm] = False, None + else: + ret[nm] = True, val + return ret + + def __setstate__(self, st): + ss = specslot.slist(self) + for i, nm in enumerate(type(self).__sslots_a__): + bound, val = st.pop(nm, (False, None)) + if not bound: + ss[i] = specslot.unbound + else: + ss[i] = val