# Τεκμηρίωση του Django - 1.10.7

# Πηγαίος κώδικας για το django.db.models.manager

    import copy
    import inspect
    from importlib import import_module

    from django.db import router
    from django.db.models.query import QuerySet
    from django.utils import six
    from django.utils.encoding import python_2_unicode_compatible

    @python_2_unicode_compatible
    class BaseManager(object):
        # Tracks each time a Manager instance is created. Used to retain order.
        creation_counter = 0

        # Set to True for the 'objects' managers that are automatically created.
        auto_created = False

        #: If set to True the manager will be serialized into migrations and will
        #: thus be available in e.g. RunPython operations
        use_in_migrations = False

        def __new__(cls, *args, **kwargs):
            # We capture the arguments to make returning them trivial
            obj = super(BaseManager, cls).__new__(cls)
            obj._constructor_args = (args, kwargs)
            return obj

        def __init__(self):
            super(BaseManager, self).__init__()
            self._set_creation_counter()
            self.model = None
            self.name = None
            self._db = None
            self._hints = {}

        def __str__(self):
            """ Return "app_label.model_label.manager_name". """
            return '%s.%s' % (self.model._meta.label, self.name)

        def deconstruct(self):
            """
            Returns a 5-tuple of the form (as_manager (True), manager_class,
            queryset_class, args, kwargs).

            Raises a ValueError if the manager is dynamically generated.
            """
            qs_class = self._queryset_class
            if getattr(self, '_built_with_as_manager', False):
                # using MyQuerySet.as_manager()
                return (
                    True,  # as_manager
                    None,  # manager_class
                    '%s.%s' % (qs_class.__module__, qs_class.__name__),  # qs_class
                    None,  # args
                    None,  # kwargs
                )
            else:
                module_name = self.__module__
                name = self.__class__.__name__
                # Make sure it's actually there and not an inner class
                module = import_module(module_name)
                if not hasattr(module, name):
                    raise ValueError(
                        "Could not find manager %s in %s.\n"
                        "Please note that you need to inherit from managers you "
                        "dynamically generated with 'from_queryset()'."
                        % (name, module_name)
                    )
                return (
                    False,  # as_manager
                    '%s.%s' % (module_name, name),  # manager_class
                    None,  # qs_class
                    self._constructor_args[0],  # args
                    self._constructor_args[1],  # kwargs
                )

        def check(self, **kwargs):
            return []

        @classmethod
        def _get_queryset_methods(cls, queryset_class):
            def create_method(name, method):
                def manager_method(self, *args, **kwargs):
                    return getattr(self.get_queryset(), name)(*args, **kwargs)
                manager_method.__name__ = method.__name__
                manager_method.__doc__ = method.__doc__
                return manager_method

            new_methods = {}
            # Refs http://bugs.python.org/issue1785.
            predicate = inspect.isfunction if six.PY3 else inspect.ismethod
            for name, method in inspect.getmembers(queryset_class, predicate=predicate):
                # Only copy missing methods.
                if hasattr(cls, name):
                    continue
                # Only copy public methods or methods with the attribute `queryset_only=False`.
                queryset_only = getattr(method, 'queryset_only', None)
                if queryset_only or (queryset_only is None and name.startswith('_')):
                    continue
                # Copy the method onto the manager.
                new_methods[name] = create_method(name, method)
            return new_methods

        @classmethod
        def from_queryset(cls, queryset_class, class_name=None):
            if class_name is None:
                class_name = '%sFrom%s' % (cls.__name__, queryset_class.__name__)
            class_dict = {
                '_queryset_class': queryset_class,
            }
            class_dict.update(cls._get_queryset_methods(queryset_class))
            return type(class_name, (cls,), class_dict)

        def contribute_to_class(self, model, name):
            if not self.name:
                self.name = name
            self.model = model

            setattr(model, name, ManagerDescriptor(self))

            model._meta.add_manager(self)

        def _set_creation_counter(self):
            """
            Sets the creation counter value for this instance and increments the
            class-level copy.
            """
            self.creation_counter = BaseManager.creation_counter
            BaseManager.creation_counter += 1

        def db_manager(self, using=None, hints=None):
            obj = copy.copy(self)
            obj._db = using or self._db
            obj._hints = hints or self._hints
            return obj

        @property
        def db(self):
            return self._db or router.db_for_read(self.model, **self._hints)

        #######################
        # PROXIES TO QUERYSET #
        #######################

        def get_queryset(self):
            """
            Returns a new QuerySet object.  Subclasses can override this method to
            easily customize the behavior of the Manager.
            """
            return self._queryset_class(model=self.model, using=self._db, hints=self._hints)

        def all(self):
            # We can't proxy this method through the `QuerySet` like we do for the
            # rest of the `QuerySet` methods. This is because `QuerySet.all()`
            # works by creating a "copy" of the current queryset and in making said
            # copy, all the cached `prefetch_related` lookups are lost. See the
            # implementation of `RelatedManager.get_queryset()` for a better
            # understanding of how this comes into play.
            return self.get_queryset()

        def __eq__(self, other):
            return (
                isinstance(other, self.__class__) and
                self._constructor_args == other._constructor_args
            )

        def __ne__(self, other):
            return not (self == other)

        def __hash__(self):
            return id(self)

    class Manager(BaseManager.from_queryset(QuerySet)):
        pass

    class ManagerDescriptor(object):

        def __init__(self, manager):
            self.manager = manager

        def __get__(self, instance, cls=None):
            if instance is not None:
                raise AttributeError("Manager isn't accessible via %s instances" % cls.__name__)

            if cls._meta.abstract:
                raise AttributeError("Manager isn't available; %s is abstract" % (
                    cls._meta.object_name,
                ))

            if cls._meta.swapped:
                raise AttributeError(
                    "Manager isn't available; '%s.%s' has been swapped for '%s'" % (
                        cls._meta.app_label,
                        cls._meta.object_name,
                        cls._meta.swapped,
                    )
                )

            return cls._meta.managers_map[self.manager.name]

    class EmptyManager(Manager):
        def __init__(self, model):
            super(EmptyManager, self).__init__()
            self.model = model

        def get_queryset(self):
            return super(EmptyManager, self).get_queryset().none()