text: import copy
  import operator
  from functools import wraps, update_wrapper
  
  
  # 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.
      """
  
      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_str = str in resultclasses
              cls._delegate_unicode = unicode in resultclasses
              assert not (cls._delegate_str and cls._delegate_unicode), "Cannot call lazy() with both str and unicode return types."
              if cls._delegate_unicode:
                  cls.__unicode__ = cls.__unicode_cast
              elif cls._delegate_str:
                  cls.__str__ = cls.__str_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 __unicode_cast(self):
              return func(*self.__args, **self.__kw)
  
          def __str_cast(self):
              return str(func(*self.__args, **self.__kw))
  
          def __cmp__(self, rhs):
              if self._delegate_str:
                  s = str(func(*self.__args, **self.__kw))
              elif self._delegate_unicode:
                  s = unicode(func(*self.__args, **self.__kw))
              else:
                  s = func(*self.__args, **self.__kw)
              if isinstance(rhs, Promise):
                  return -cmp(rhs, s)
              else:
                  return cmp(s, rhs)
  
          def __mod__(self, rhs):
              if self._delegate_str:
                  return str(self) % rhs
              elif self._delegate_unicode:
                  return unicode(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) + kwargs.values():
              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:
      __members__ = property(lambda self: self.__dir__())
      __dir__ = new_method_proxy(dir)
  
  
  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()
  
      __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__
  
      # 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)
      __nonzero__ = new_method_proxy(bool)
  
  
  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 > 3, range(5))
          [1, 2, 3], [4]
      """
      results = ([], [])
      for item in values:
          results[predicate(item)].append(item)
      return results
  