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