From: Fredrik Tolf <fredrik@dolda2000.com>
Date: Wed, 27 Jun 2012 04:48:08 +0000 (+0200)
Subject: Merge branch 'master' into python3
X-Git-Url: http://dolda2000.com/gitweb/?p=wrw.git;a=commitdiff_plain;h=f605aaf2dc0a63ae210cfe26cc21de68533cbc08;hp=-c

Merge branch 'master' into python3
---

f605aaf2dc0a63ae210cfe26cc21de68533cbc08
diff --combined wrw/util.py
index c8b7b2c,5ee002b..a7f1e4c
--- a/wrw/util.py
+++ b/wrw/util.py
@@@ -1,20 -1,11 +1,20 @@@
  import inspect
 -import req, dispatch, session, form
 +from . import req, dispatch, session, form
  
  def wsgiwrap(callable):
      def wrapper(env, startreq):
          return dispatch.handle(req.origrequest(env), startreq, 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):
      def wrapper(req):
          data = form.formdata(req)
@@@ -64,7 -55,7 +64,7 @@@ class sessiondata(object)
  class autodirty(sessiondata):
      @classmethod
      def get(cls, req):
 -        ret = super(autodirty, cls).get(req)
 +        ret = super().get(req)
          if "_is_dirty" not in ret.__dict__:
              ret.__dict__["_is_dirty"] = False
          return ret
@@@ -76,18 -67,18 +76,18 @@@
          return self._is_dirty
  
      def __setattr__(self, name, value):
 -        super(autodirty, self).__setattr__(name, value)
 +        super().__setattr__(name, value)
          if "_is_dirty" in self.__dict__:
              self.__dict__["_is_dirty"] = True
  
      def __delattr__(self, name):
 -        super(autodirty, self).__delattr__(name, value)
 +        super().__delattr__(name, value)
          if "_is_dirty" in self.__dict__:
              self.__dict__["_is_dirty"] = True
  
  class manudirty(object):
      def __init__(self, *args, **kwargs):
 -        super(manudirty, self).__init__(*args, **kwargs)
 +        super().__init__(*args, **kwargs)
          self.__dirty = False
  
      def sessfrozen(self):
@@@ -98,3 -89,92 +98,91 @@@
  
      def dirty(self):
          self.__dirty = True
+ 
+ class specslot(object):
+     __slots__ = ["nm", "idx", "dirty"]
+     unbound = object()
+     
+     def __init__(self, nm, idx, dirty):
+         self.nm = nm
+         self.idx = idx
+         self.dirty = dirty
+ 
+     @staticmethod
+     def slist(ins):
+         # Avoid calling __getattribute__
+         return specdirty.__sslots__.__get__(ins, type(ins))
+ 
+     def __get__(self, ins, cls):
+         val = self.slist(ins)[self.idx]
+         if val is specslot.unbound:
+             raise AttributeError("specslot %r is unbound" % self.nm)
+         return val
+ 
+     def __set__(self, ins, val):
+         self.slist(ins)[self.idx] = val
+         if self.dirty:
+             ins.dirty()
+ 
+     def __delete__(self, ins):
+         self.slist(ins)[self.idx] = specslot.unbound
+         ins.dirty()
+ 
+ class specclass(type):
+     def __init__(self, name, bases, tdict):
 -        super(specclass, self).__init__(name, bases, tdict)
++        super().__init__(name, bases, tdict)
+         sslots = set()
+         dslots = set()
+         for cls in self.__mro__:
+             css = cls.__dict__.get("__saveslots__", ())
+             sslots.update(css)
+             dslots.update(cls.__dict__.get("__dirtyslots__", css))
+         self.__sslots_l__ = list(sslots)
+         self.__sslots_a__ = list(sslots | dslots)
+         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):
+         pass
+ 
+     @staticmethod
+     def __new__(cls, req, sess):
 -        self = super(specdirty, cls).__new__(cls)
++        self = super().__new__(cls)
+         self.session = sess
+         self.__sslots__ = [specslot.unbound] * len(cls.__sslots_a__)
+         self.__specinit__()
+         self._is_dirty = False
+         return self
+ 
+     def __getnewargs__(self):
+         return (None, self.session)
+ 
+     def dirty(self):
+         self._is_dirty = True
+ 
+     def sessfrozen(self):
+         self._is_dirty = False
+ 
+     def sessdirty(self):
+         return self._is_dirty
+ 
+     def __getstate__(self):
+         ret = {}
+         for nm, val in zip(type(self).__sslots_a__, specslot.slist(self)):
+             if val is specslot.unbound:
+                 ret[nm] = False, None
+             else:
+                 ret[nm] = True, val
+         return ret
+ 
+     def __setstate__(self, st):
+         ss = specslot.slist(self)
+         for i, nm in enumerate(type(self).__sslots_a__):
+             bound, val = st.pop(nm, (False, None))
+             if not bound:
+                 ss[i] = specslot.unbound
+             else:
+                 ss[i] = val