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