| import copy |
| import operator |
| from functools import wraps, update_wrapper |
| import sys |
| |
| from django.utils import six |
| from django.utils.six.moves import copyreg |
| |
| |
| # You can't trivially replace this `functools.partial` because this binds to |
| # classes and returns bound instances, whereas functools.partial (on CPython) |
| # is a type and its instances don't bind. |
| def curry(_curried_func, *args, **kwargs): |
| def _curried(*moreargs, **morekwargs): |
| return _curried_func(*(args+moreargs), **dict(kwargs, **morekwargs)) |
| return _curried |
| |
| def memoize(func, cache, num_args): |
| """ |
| Wrap a function so that results for any argument tuple are stored in |
| 'cache'. Note that the args to the function must be usable as dictionary |
| keys. |
| |
| Only the first num_args are considered when creating the key. |
| """ |
| @wraps(func) |
| def wrapper(*args): |
| mem_args = args[:num_args] |
| if mem_args in cache: |
| return cache[mem_args] |
| result = func(*args) |
| cache[mem_args] = result |
| return result |
| return wrapper |
| |
| class cached_property(object): |
| """ |
| Decorator that creates converts a method with a single |
| self argument into a property cached on the instance. |
| """ |
| def __init__(self, func): |
| self.func = func |
| |
| def __get__(self, instance, type): |
| res = instance.__dict__[self.func.__name__] = self.func(instance) |
| return res |
| |
| class Promise(object): |
| """ |
| This is just a base class for the proxy class created in |
| the closure of the lazy function. It can be used to recognize |
| promises in code. |
| """ |
| pass |
| |
| def lazy(func, *resultclasses): |
| """ |
| Turns any callable into a lazy evaluated callable. You need to give result |
| classes or types -- at least one is needed so that the automatic forcing of |
| the lazy evaluation code is triggered. Results are not memoized; the |
| function is evaluated on every access. |
| """ |
| |
| @total_ordering |
| class __proxy__(Promise): |
| """ |
| Encapsulate a function call and act as a proxy for methods that are |
| called on the result of that function. The function is not evaluated |
| until one of the methods on the result is called. |
| """ |
| __dispatch = None |
| |
| def __init__(self, args, kw): |
| self.__args = args |
| self.__kw = kw |
| if self.__dispatch is None: |
| self.__prepare_class__() |
| |
| def __reduce__(self): |
| return ( |
| _lazy_proxy_unpickle, |
| (func, self.__args, self.__kw) + resultclasses |
| ) |
| |
| def __prepare_class__(cls): |
| cls.__dispatch = {} |
| for resultclass in resultclasses: |
| cls.__dispatch[resultclass] = {} |
| for type_ in reversed(resultclass.mro()): |
| for (k, v) in type_.__dict__.items(): |
| # All __promise__ return the same wrapper method, but they |
| # also do setup, inserting the method into the dispatch |
| # dict. |
| meth = cls.__promise__(resultclass, k, v) |
| if hasattr(cls, k): |
| continue |
| setattr(cls, k, meth) |
| cls._delegate_bytes = bytes in resultclasses |
| cls._delegate_text = six.text_type in resultclasses |
| assert not (cls._delegate_bytes and cls._delegate_text), "Cannot call lazy() with both bytes and text return types." |
| if cls._delegate_text: |
| if six.PY3: |
| cls.__str__ = cls.__text_cast |
| else: |
| cls.__unicode__ = cls.__text_cast |
| elif cls._delegate_bytes: |
| if six.PY3: |
| cls.__bytes__ = cls.__bytes_cast |
| else: |
| cls.__str__ = cls.__bytes_cast |
| __prepare_class__ = classmethod(__prepare_class__) |
| |
| def __promise__(cls, klass, funcname, method): |
| # Builds a wrapper around some magic method and registers that magic |
| # method for the given type and method name. |
| def __wrapper__(self, *args, **kw): |
| # Automatically triggers the evaluation of a lazy value and |
| # applies the given magic method of the result type. |
| res = func(*self.__args, **self.__kw) |
| for t in type(res).mro(): |
| if t in self.__dispatch: |
| return self.__dispatch[t][funcname](res, *args, **kw) |
| raise TypeError("Lazy object returned unexpected type.") |
| |
| if klass not in cls.__dispatch: |
| cls.__dispatch[klass] = {} |
| cls.__dispatch[klass][funcname] = method |
| return __wrapper__ |
| __promise__ = classmethod(__promise__) |
| |
| def __text_cast(self): |
| return func(*self.__args, **self.__kw) |
| |
| def __bytes_cast(self): |
| return bytes(func(*self.__args, **self.__kw)) |
| |
| def __cast(self): |
| if self._delegate_bytes: |
| return self.__bytes_cast() |
| elif self._delegate_text: |
| return self.__text_cast() |
| else: |
| return func(*self.__args, **self.__kw) |
| |
| def __eq__(self, other): |
| if isinstance(other, Promise): |
| other = other.__cast() |
| return self.__cast() == other |
| |
| def __lt__(self, other): |
| if isinstance(other, Promise): |
| other = other.__cast() |
| return self.__cast() < other |
| |
| def __hash__(self): |
| return hash(self.__cast()) |
| |
| def __mod__(self, rhs): |
| if self._delegate_bytes and not six.PY3: |
| return bytes(self) % rhs |
| elif self._delegate_text: |
| return six.text_type(self) % rhs |
| else: |
| raise AssertionError('__mod__ not supported for non-string types') |
| |
| def __deepcopy__(self, memo): |
| # Instances of this class are effectively immutable. It's just a |
| # collection of functions. So we don't need to do anything |
| # complicated for copying. |
| memo[id(self)] = self |
| return self |
| |
| @wraps(func) |
| def __wrapper__(*args, **kw): |
| # Creates the proxy object, instead of the actual value. |
| return __proxy__(args, kw) |
| |
| return __wrapper__ |
| |
| def _lazy_proxy_unpickle(func, args, kwargs, *resultclasses): |
| return lazy(func, *resultclasses)(*args, **kwargs) |
| |
| def allow_lazy(func, *resultclasses): |
| """ |
| A decorator that allows a function to be called with one or more lazy |
| arguments. If none of the args are lazy, the function is evaluated |
| immediately, otherwise a __proxy__ is returned that will evaluate the |
| function when needed. |
| """ |
| @wraps(func) |
| def wrapper(*args, **kwargs): |
| for arg in list(args) + list(six.itervalues(kwargs)): |
| if isinstance(arg, Promise): |
| break |
| else: |
| return func(*args, **kwargs) |
| return lazy(func, *resultclasses)(*args, **kwargs) |
| return wrapper |
| |
| empty = object() |
| def new_method_proxy(func): |
| def inner(self, *args): |
| if self._wrapped is empty: |
| self._setup() |
| return func(self._wrapped, *args) |
| return inner |
| |
| class LazyObject(object): |
| """ |
| A wrapper for another class that can be used to delay instantiation of the |
| wrapped class. |
| |
| By subclassing, you have the opportunity to intercept and alter the |
| instantiation. If you don't need to do that, use SimpleLazyObject. |
| """ |
| def __init__(self): |
| self._wrapped = empty |
| |
| __getattr__ = new_method_proxy(getattr) |
| |
| def __setattr__(self, name, value): |
| if name == "_wrapped": |
| # Assign to __dict__ to avoid infinite __setattr__ loops. |
| self.__dict__["_wrapped"] = value |
| else: |
| if self._wrapped is empty: |
| self._setup() |
| setattr(self._wrapped, name, value) |
| |
| def __delattr__(self, name): |
| if name == "_wrapped": |
| raise TypeError("can't delete _wrapped.") |
| if self._wrapped is empty: |
| self._setup() |
| delattr(self._wrapped, name) |
| |
| def _setup(self): |
| """ |
| Must be implemented by subclasses to initialise the wrapped object. |
| """ |
| raise NotImplementedError |
| |
| # introspection support: |
| __dir__ = new_method_proxy(dir) |
| |
| |
| # Workaround for http://bugs.python.org/issue12370 |
| _super = super |
| |
| class SimpleLazyObject(LazyObject): |
| """ |
| A lazy object initialised from any function. |
| |
| Designed for compound objects of unknown type. For builtins or objects of |
| known type, use django.utils.functional.lazy. |
| """ |
| def __init__(self, func): |
| """ |
| Pass in a callable that returns the object to be wrapped. |
| |
| If copies are made of the resulting SimpleLazyObject, which can happen |
| in various circumstances within Django, then you must ensure that the |
| callable can be safely run more than once and will return the same |
| value. |
| """ |
| self.__dict__['_setupfunc'] = func |
| _super(SimpleLazyObject, self).__init__() |
| |
| def _setup(self): |
| self._wrapped = self._setupfunc() |
| |
| if six.PY3: |
| __bytes__ = new_method_proxy(bytes) |
| __str__ = new_method_proxy(str) |
| else: |
| __str__ = new_method_proxy(str) |
| __unicode__ = new_method_proxy(unicode) |
| |
| def __deepcopy__(self, memo): |
| if self._wrapped is empty: |
| # We have to use SimpleLazyObject, not self.__class__, because the |
| # latter is proxied. |
| result = SimpleLazyObject(self._setupfunc) |
| memo[id(self)] = result |
| return result |
| else: |
| return copy.deepcopy(self._wrapped, memo) |
| |
| # Because we have messed with __class__ below, we confuse pickle as to what |
| # class we are pickling. It also appears to stop __reduce__ from being |
| # called. So, we define __getstate__ in a way that cooperates with the way |
| # that pickle interprets this class. This fails when the wrapped class is a |
| # builtin, but it is better than nothing. |
| def __getstate__(self): |
| if self._wrapped is empty: |
| self._setup() |
| return self._wrapped.__dict__ |
| |
| # Python 3.3 will call __reduce__ when pickling; this method is needed |
| # to serialize and deserialize correctly. |
| @classmethod |
| def __newobj__(cls, *args): |
| return cls.__new__(cls, *args) |
| |
| def __reduce_ex__(self, proto): |
| if proto >= 2: |
| # On Py3, since the default protocol is 3, pickle uses the |
| # ``__newobj__`` method (& more efficient opcodes) for writing. |
| return (self.__newobj__, (self.__class__,), self.__getstate__()) |
| else: |
| # On Py2, the default protocol is 0 (for back-compat) & the above |
| # code fails miserably (see regression test). Instead, we return |
| # exactly what's returned if there's no ``__reduce__`` method at |
| # all. |
| return (copyreg._reconstructor, (self.__class__, object, None), self.__getstate__()) |
| |
| # Need to pretend to be the wrapped class, for the sake of objects that care |
| # about this (especially in equality tests) |
| __class__ = property(new_method_proxy(operator.attrgetter("__class__"))) |
| __eq__ = new_method_proxy(operator.eq) |
| __hash__ = new_method_proxy(hash) |
| __bool__ = new_method_proxy(bool) # Python 3 |
| __nonzero__ = __bool__ # Python 2 |
| |
| |
| class lazy_property(property): |
| """ |
| A property that works with subclasses by wrapping the decorated |
| functions of the base class. |
| """ |
| def __new__(cls, fget=None, fset=None, fdel=None, doc=None): |
| if fget is not None: |
| @wraps(fget) |
| def fget(instance, instance_type=None, name=fget.__name__): |
| return getattr(instance, name)() |
| if fset is not None: |
| @wraps(fset) |
| def fset(instance, value, name=fset.__name__): |
| return getattr(instance, name)(value) |
| if fdel is not None: |
| @wraps(fdel) |
| def fdel(instance, name=fdel.__name__): |
| return getattr(instance, name)() |
| return property(fget, fset, fdel, doc) |
| |
| def partition(predicate, values): |
| """ |
| Splits the values into two sets, based on the return value of the function |
| (True/False). e.g.: |
| |
| >>> partition(lambda x: x > 3, range(5)) |
| [0, 1, 2, 3], [4] |
| """ |
| results = ([], []) |
| for item in values: |
| results[predicate(item)].append(item) |
| return results |
| |
| if sys.version_info >= (2,7,2): |
| from functools import total_ordering |
| else: |
| # For Python < 2.7.2. Python 2.6 does not have total_ordering, and |
| # total_ordering in 2.7 versions prior to 2.7.2 is buggy. See |
| # http://bugs.python.org/issue10042 for details. For these versions use |
| # code borrowed from Python 2.7.3. |
| def total_ordering(cls): |
| """Class decorator that fills in missing ordering methods""" |
| convert = { |
| '__lt__': [('__gt__', lambda self, other: not (self < other or self == other)), |
| ('__le__', lambda self, other: self < other or self == other), |
| ('__ge__', lambda self, other: not self < other)], |
| '__le__': [('__ge__', lambda self, other: not self <= other or self == other), |
| ('__lt__', lambda self, other: self <= other and not self == other), |
| ('__gt__', lambda self, other: not self <= other)], |
| '__gt__': [('__lt__', lambda self, other: not (self > other or self == other)), |
| ('__ge__', lambda self, other: self > other or self == other), |
| ('__le__', lambda self, other: not self > other)], |
| '__ge__': [('__le__', lambda self, other: (not self >= other) or self == other), |
| ('__gt__', lambda self, other: self >= other and not self == other), |
| ('__lt__', lambda self, other: not self >= other)] |
| } |
| roots = set(dir(cls)) & set(convert) |
| if not roots: |
| raise ValueError('must define at least one ordering operation: < > <= >=') |
| root = max(roots) # prefer __lt__ to __le__ to __gt__ to __ge__ |
| for opname, opfunc in convert[root]: |
| if opname not in roots: |
| opfunc.__name__ = opname |
| opfunc.__doc__ = getattr(int, opname).__doc__ |
| setattr(cls, opname, opfunc) |
| return cls |
