X-Git-Url: http://dolda2000.com/gitweb/?a=blobdiff_plain;f=wrw%2Futil.py;h=22bce9de3cdc0f3df5f2ca63988516bd1c9dd3a1;hb=b6f62b898efdc272130d3dbdd6742c5b785e7c7d;hp=eb2768319804b40caa2f78765fbb78661263187c;hpb=8fec8547c47c0452333972f554f328d0c8e61be2;p=wrw.git diff --git a/wrw/util.py b/wrw/util.py index eb27683..22bce9d 100644 --- a/wrw/util.py +++ b/wrw/util.py @@ -1,41 +1,45 @@ -import inspect -from . import req, dispatch, session, form, resp +import inspect, math +import req, dispatch, session, form, resp, proto def wsgiwrap(callable): def wrapper(env, startreq): return dispatch.handleenv(env, startreq, callable) + wrapper.__wrapped__ = 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): + spec = inspect.getargspec(callable) def wrapper(req): - data = form.formdata(req) - spec = inspect.getargspec(callable) + try: + data = form.formdata(req) + except IOError: + raise resp.httperror(400, "Invalid request", "Form data was incomplete") args = dict(data.items()) args["req"] = req if not spec.keywords: for arg in list(args): if arg not in spec.args: del args[arg] - for i in range(len(spec.args) - len(spec.defaults)): + for i in xrange(len(spec.args) - (len(spec.defaults) if spec.defaults else 0)): 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) + wrapper.__wrapped__ = callable return wrapper -def funplex(*funs, **nfuns): - dir = {} - dir.update(((fun.__name__, fun) for fun in funs)) - dir.update(nfuns) - def handler(req): +class funplex(object): + def __init__(self, *funs, **nfuns): + self.dir = {} + self.dir.update(((self.unwrap(fun).__name__, fun) for fun in funs)) + self.dir.update(nfuns) + + @staticmethod + def unwrap(fun): + while hasattr(fun, "__wrapped__"): + fun = fun.__wrapped__ + return fun + + def __call__(self, req): if req.pathinfo == "": raise resp.redirect(req.uriname + "/") if req.pathinfo[:1] != "/": @@ -47,12 +51,23 @@ def funplex(*funs, **nfuns): else: p = p.partition("/")[0] bi = len(p) + 1 - if p in dir: - return dir[p](req.shift(bi)) + if p in self.dir: + sreq = req.shift(bi) + sreq.selfpath = req.pathinfo[1:] + return self.dir[p](sreq) raise resp.notfound() - return handler -def persession(data = None): + def add(self, fun): + self.dir[self.unwrap(fun).__name__] = fun + return fun + + def name(self, name): + def dec(fun): + self.dir[name] = fun + return fun + return dec + +def persession(data=None): def dec(callable): def wrapper(req): sess = session.get(req) @@ -64,6 +79,7 @@ def persession(data = None): sess[data] = data() sess[callable] = callable(data) return sess[callable].handle(req) + wrapper.__wrapped__ = callable return wrapper return dec @@ -74,12 +90,12 @@ class preiter(object): self.bk = real self.bki = iter(real) self._next = None - self.__next__() + self.next() def __iter__(self): return self - def __next__(self): + def next(self): if self._next is self.end: raise StopIteration() ret = self._next @@ -96,11 +112,12 @@ class preiter(object): def pregen(callable): def wrapper(*args, **kwargs): return preiter(callable(*args, **kwargs)) + wrapper.__wrapped__ = callable return wrapper class sessiondata(object): @classmethod - def get(cls, req, create = True): + def get(cls, req, create=True): sess = cls.sessdb().get(req) with sess.lock: try: @@ -119,7 +136,7 @@ class sessiondata(object): class autodirty(sessiondata): @classmethod def get(cls, req): - ret = super().get(req) + ret = super(autodirty, cls).get(req) if "_is_dirty" not in ret.__dict__: ret.__dict__["_is_dirty"] = False return ret @@ -131,18 +148,18 @@ class autodirty(sessiondata): return self._is_dirty def __setattr__(self, name, value): - super().__setattr__(name, value) + super(autodirty, self).__setattr__(name, value) if "_is_dirty" in self.__dict__: self.__dict__["_is_dirty"] = True def __delattr__(self, name): - super().__delattr__(name, value) + super(autodirty, self).__delattr__(name, value) if "_is_dirty" in self.__dict__: self.__dict__["_is_dirty"] = True class manudirty(object): def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) + super(manudirty, self).__init__(*args, **kwargs) self.__dirty = False def sessfrozen(self): @@ -185,7 +202,7 @@ class specslot(object): class specclass(type): def __init__(self, name, bases, tdict): - super().__init__(name, bases, tdict) + super(specclass, self).__init__(name, bases, tdict) sslots = set() dslots = set() for cls in self.__mro__: @@ -197,7 +214,8 @@ class specclass(type): for i, slot in enumerate(self.__sslots_a__): setattr(self, slot, specslot(slot, i, slot in dslots)) -class specdirty(sessiondata, metaclass=specclass): +class specdirty(sessiondata): + __metaclass__ = specclass __slots__ = ["session", "__sslots__", "_is_dirty"] def __specinit__(self): @@ -205,7 +223,7 @@ class specdirty(sessiondata, metaclass=specclass): @staticmethod def __new__(cls, req, sess): - self = super().__new__(cls) + self = super(specdirty, cls).__new__(cls) self.session = sess self.__sslots__ = [specslot.unbound] * len(cls.__sslots_a__) self.__specinit__() @@ -241,3 +259,10 @@ class specdirty(sessiondata, metaclass=specclass): ss[i] = specslot.unbound else: ss[i] = val + +def datecheck(req, mtime): + if "If-Modified-Since" in req.ihead: + rtime = proto.phttpdate(req.ihead["If-Modified-Since"]) + if rtime is not None and rtime >= math.floor(mtime): + raise resp.unmodified() + req.ohead["Last-Modified"] = proto.httpdate(mtime)