Commit | Line | Data |
---|---|---|
1f9d8560 | 1 | from __future__ import with_statement |
bbdebbab FT |
2 | import inspect |
3 | import req, dispatch, session, form | |
b409a338 FT |
4 | |
5 | def wsgiwrap(callable): | |
6 | def wrapper(env, startreq): | |
0a59819d | 7 | return dispatch.handle(req.origrequest(env), startreq, 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 | |
b342d9b2 | 16 | if not spec[2]: |
bbdebbab | 17 | for arg in list(args): |
b342d9b2 | 18 | if arg not in spec[0]: |
bbdebbab FT |
19 | del args[arg] |
20 | return callable(**args) | |
21 | return wrapper | |
22 | ||
d9979128 FT |
23 | def persession(data = None): |
24 | def dec(callable): | |
25 | def wrapper(req): | |
26 | sess = session.get(req) | |
27 | if callable not in sess: | |
28 | if data is None: | |
29 | sess[callable] = callable() | |
30 | else: | |
31 | if data not in sess: | |
32 | sess[data] = data() | |
33 | sess[callable] = callable(data) | |
34 | return sess[callable].handle(req) | |
35 | return wrapper | |
36 | return dec | |
d1f70c6c FT |
37 | |
38 | class sessiondata(object): | |
39 | @classmethod | |
8f911ff6 | 40 | def get(cls, req, create = True): |
d1f70c6c FT |
41 | sess = cls.sessdb().get(req) |
42 | with sess.lock: | |
43 | try: | |
44 | return sess[cls] | |
45 | except KeyError: | |
8f911ff6 FT |
46 | if not create: |
47 | return None | |
5b35322c | 48 | ret = cls(req, sess) |
d1f70c6c FT |
49 | sess[cls] = ret |
50 | return ret | |
51 | ||
52 | @classmethod | |
53 | def sessdb(cls): | |
1f61bf31 | 54 | return session.default.val |
d1f70c6c | 55 | |
f13b8f5a FT |
56 | class autodirty(sessiondata): |
57 | @classmethod | |
58 | def get(cls, req): | |
59 | ret = super(autodirty, cls).get(req) | |
60 | if "_is_dirty" not in ret.__dict__: | |
61 | ret.__dict__["_is_dirty"] = False | |
617b21df | 62 | return ret |
f13b8f5a | 63 | |
d1f70c6c | 64 | def sessfrozen(self): |
f13b8f5a | 65 | self.__dict__["_is_dirty"] = False |
d1f70c6c FT |
66 | |
67 | def sessdirty(self): | |
f13b8f5a | 68 | return self._is_dirty |
d1f70c6c FT |
69 | |
70 | def __setattr__(self, name, value): | |
f13b8f5a FT |
71 | super(autodirty, self).__setattr__(name, value) |
72 | if "_is_dirty" in self.__dict__: | |
73 | self.__dict__["_is_dirty"] = True | |
d1f70c6c FT |
74 | |
75 | def __delattr__(self, name): | |
f13b8f5a FT |
76 | super(autodirty, self).__delattr__(name, value) |
77 | if "_is_dirty" in self.__dict__: | |
78 | self.__dict__["_is_dirty"] = True | |
3b9bc700 FT |
79 | |
80 | class manudirty(object): | |
81 | def __init__(self, *args, **kwargs): | |
82 | super(manudirty, self).__init__(*args, **kwargs) | |
83 | self.__dirty = False | |
84 | ||
85 | def sessfrozen(self): | |
86 | self.__dirty = False | |
87 | ||
88 | def sessdirty(self): | |
89 | return self.__dirty | |
90 | ||
91 | def dirty(self): | |
92 | self.__dirty = True | |
df5f7868 FT |
93 | |
94 | class specslot(object): | |
95 | __slots__ = ["nm", "idx", "dirty"] | |
96 | unbound = object() | |
97 | ||
98 | def __init__(self, nm, idx, dirty): | |
99 | self.nm = nm | |
100 | self.idx = idx | |
101 | self.dirty = dirty | |
102 | ||
103 | @staticmethod | |
104 | def slist(ins): | |
105 | # Avoid calling __getattribute__ | |
106 | return specdirty.__sslots__.__get__(ins, type(ins)) | |
107 | ||
108 | def __get__(self, ins, cls): | |
109 | val = self.slist(ins)[self.idx] | |
110 | if val is specslot.unbound: | |
111 | raise AttributeError("specslot %r is unbound" % self.nm) | |
112 | return val | |
113 | ||
114 | def __set__(self, ins, val): | |
115 | self.slist(ins)[self.idx] = val | |
116 | if self.dirty: | |
117 | ins.dirty() | |
118 | ||
119 | def __delete__(self, ins): | |
120 | self.slist(ins)[self.idx] = specslot.unbound | |
121 | ins.dirty() | |
122 | ||
123 | class specclass(type): | |
124 | def __init__(self, name, bases, tdict): | |
125 | super(specclass, self).__init__(name, bases, tdict) | |
126 | sslots = set() | |
127 | dslots = set() | |
128 | for cls in self.__mro__: | |
129 | css = cls.__dict__.get("__saveslots__", ()) | |
130 | sslots.update(css) | |
131 | dslots.update(cls.__dict__.get("__dirtyslots__", css)) | |
132 | self.__sslots_l__ = list(sslots) | |
133 | self.__sslots_a__ = list(sslots | dslots) | |
134 | for i, slot in enumerate(self.__sslots_a__): | |
135 | setattr(self, slot, specslot(slot, i, slot in dslots)) | |
136 | ||
137 | class specdirty(sessiondata): | |
138 | __metaclass__ = specclass | |
139 | __slots__ = ["session", "__sslots__", "_is_dirty"] | |
140 | ||
141 | def __specinit__(self): | |
142 | pass | |
143 | ||
144 | @staticmethod | |
145 | def __new__(cls, req, sess): | |
146 | self = super(specdirty, cls).__new__(cls) | |
147 | self.session = sess | |
148 | self.__sslots__ = [specslot.unbound] * len(cls.__sslots_a__) | |
149 | self.__specinit__() | |
150 | self._is_dirty = False | |
151 | return self | |
152 | ||
153 | def __getnewargs__(self): | |
154 | return (None, self.session) | |
155 | ||
156 | def dirty(self): | |
157 | self._is_dirty = True | |
158 | ||
159 | def sessfrozen(self): | |
160 | self._is_dirty = False | |
161 | ||
162 | def sessdirty(self): | |
163 | return self._is_dirty | |
164 | ||
165 | def __getstate__(self): | |
166 | ret = {} | |
167 | for nm, val in zip(type(self).__sslots_a__, specslot.slist(self)): | |
168 | if val is specslot.unbound: | |
169 | ret[nm] = False, None | |
170 | else: | |
171 | ret[nm] = True, val | |
172 | return ret | |
173 | ||
174 | def __setstate__(self, st): | |
175 | ss = specslot.slist(self) | |
176 | for i, nm in enumerate(type(self).__sslots_a__): | |
177 | bound, val = st.pop(nm, (False, None)) | |
df5f7868 FT |
178 | if not bound: |
179 | ss[i] = specslot.unbound | |
180 | else: | |
181 | ss[i] = val |