text: import copy
  
  from django.db.models.query import QuerySet, EmptyQuerySet, insert_query
  from django.db.models import signals
  from django.db.models.fields import FieldDoesNotExist
  
  def ensure_default_manager(sender, **kwargs):
      """
      Ensures that a Model subclass contains a default manager  and sets the
      _default_manager attribute on the class. Also sets up the _base_manager
      points to a plain Manager instance (which could be the same as
      _default_manager if it's not a subclass of Manager).
      """
      cls = sender
      if cls._meta.abstract:
          return
      if not getattr(cls, '_default_manager', None):
          # Create the default manager, if needed.
          try:
              cls._meta.get_field('objects')
              raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % cls.__name__
          except FieldDoesNotExist:
              pass
          cls.add_to_class('objects', Manager())
          cls._base_manager = cls.objects
      elif not getattr(cls, '_base_manager', None):
          default_mgr = cls._default_manager.__class__
          if (default_mgr is Manager or
                  getattr(default_mgr, "use_for_related_fields", False)):
              cls._base_manager = cls._default_manager
          else:
              # Default manager isn't a plain Manager class, or a suitable
              # replacement, so we walk up the base class hierarchy until we hit
              # something appropriate.
              for base_class in default_mgr.mro()[1:]:
                  if (base_class is Manager or
                          getattr(base_class, "use_for_related_fields", False)):
                      cls.add_to_class('_base_manager', base_class())
                      return
              raise AssertionError("Should never get here. Please report a bug, including your model and model manager setup.")
  
  signals.class_prepared.connect(ensure_default_manager)
  
  class Manager(object):
      # Tracks each time a Manager instance is created. Used to retain order.
      creation_counter = 0
  
      def __init__(self):
          super(Manager, self).__init__()
          self._set_creation_counter()
          self.model = None
          self._inherited = False
  
      def contribute_to_class(self, model, name):
          # TODO: Use weakref because of possible memory leak / circular reference.
          self.model = model
          setattr(model, name, ManagerDescriptor(self))
          if not getattr(model, '_default_manager', None) or self.creation_counter < model._default_manager.creation_counter:
              model._default_manager = self
          if model._meta.abstract or self._inherited:
              model._meta.abstract_managers.append((self.creation_counter, name,
                      self))
          else:
              model._meta.concrete_managers.append((self.creation_counter, name,
                  self))
  
      def _set_creation_counter(self):
          """
          Sets the creation counter value for this instance and increments the
          class-level copy.
          """
          self.creation_counter = Manager.creation_counter
          Manager.creation_counter += 1
  
      def _copy_to_model(self, model):
          """
          Makes a copy of the manager and assigns it to 'model', which should be
          a child of the existing model (used when inheriting a manager from an
          abstract base class).
          """
          assert issubclass(model, self.model)
          mgr = copy.copy(self)
          mgr._set_creation_counter()
          mgr.model = model
          mgr._inherited = True
          return mgr
  
      #######################
      # PROXIES TO QUERYSET #
      #######################
  
      def get_empty_query_set(self):
          return EmptyQuerySet(self.model)
  
      def get_query_set(self):
          """Returns a new QuerySet object.  Subclasses can override this method
          to easily customize the behavior of the Manager.
          """
          return QuerySet(self.model)
  
      def none(self):
          return self.get_empty_query_set()
  
      def all(self):
          return self.get_query_set()
  
      def count(self):
          return self.get_query_set().count()
  
      def dates(self, *args, **kwargs):
          return self.get_query_set().dates(*args, **kwargs)
  
      def distinct(self, *args, **kwargs):
          return self.get_query_set().distinct(*args, **kwargs)
  
      def extra(self, *args, **kwargs):
          return self.get_query_set().extra(*args, **kwargs)
  
      def get(self, *args, **kwargs):
          return self.get_query_set().get(*args, **kwargs)
  
      def get_or_create(self, **kwargs):
          return self.get_query_set().get_or_create(**kwargs)
  
      def create(self, **kwargs):
          return self.get_query_set().create(**kwargs)
  
      def filter(self, *args, **kwargs):
          return self.get_query_set().filter(*args, **kwargs)
  
      def aggregate(self, *args, **kwargs):
          return self.get_query_set().aggregate(*args, **kwargs)
  
      def annotate(self, *args, **kwargs):
          return self.get_query_set().annotate(*args, **kwargs)
  
      def complex_filter(self, *args, **kwargs):
          return self.get_query_set().complex_filter(*args, **kwargs)
  
      def exclude(self, *args, **kwargs):
          return self.get_query_set().exclude(*args, **kwargs)
  
      def in_bulk(self, *args, **kwargs):
          return self.get_query_set().in_bulk(*args, **kwargs)
  
      def iterator(self, *args, **kwargs):
          return self.get_query_set().iterator(*args, **kwargs)
  
      def latest(self, *args, **kwargs):
          return self.get_query_set().latest(*args, **kwargs)
  
      def order_by(self, *args, **kwargs):
          return self.get_query_set().order_by(*args, **kwargs)
  
      def select_related(self, *args, **kwargs):
          return self.get_query_set().select_related(*args, **kwargs)
  
      def values(self, *args, **kwargs):
          return self.get_query_set().values(*args, **kwargs)
  
      def values_list(self, *args, **kwargs):
          return self.get_query_set().values_list(*args, **kwargs)
  
      def update(self, *args, **kwargs):
          return self.get_query_set().update(*args, **kwargs)
  
      def reverse(self, *args, **kwargs):
          return self.get_query_set().reverse(*args, **kwargs)
  
      def defer(self, *args, **kwargs):
          return self.get_query_set().defer(*args, **kwargs)
  
      def only(self, *args, **kwargs):
          return self.get_query_set().only(*args, **kwargs)
  
      def _insert(self, values, **kwargs):
          return insert_query(self.model, values, **kwargs)
  
      def _update(self, values, **kwargs):
          return self.get_query_set()._update(values, **kwargs)
  
  class ManagerDescriptor(object):
      # This class ensures managers aren't accessible via model instances.
      # For example, Poll.objects works, but poll_obj.objects raises AttributeError.
      def __init__(self, manager):
          self.manager = manager
  
      def __get__(self, instance, type=None):
          if instance != None:
              raise AttributeError, "Manager isn't accessible via %s instances" % type.__name__
          return self.manager
  
  class EmptyManager(Manager):
      def get_query_set(self):
          return self.get_empty_query_set()
  