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