

@cached_property
def related_manager_cls(self):
    superclass = self.related.model._default_manager.__class__
    rel_field = self.related.field
    rel_model = self.related.model
    attname = rel_field.rel.get_related_field().attname

    class RelatedManager(superclass):

        def __init__(self, instance):
            super(RelatedManager, self).__init__()
            self.instance = instance
            self.core_filters = {
                ('%s__%s' % (rel_field.name, attname)): getattr(instance, attname),
            }
            self.model = rel_model

        def get_query_set(self):
            try:
                return self.instance._prefetched_objects_cache[rel_field.related_query_name()]
            except (AttributeError, KeyError):
                db = (self._db or router.db_for_read(self.model, instance=self.instance))
                qs = super(RelatedManager, self).get_query_set().using(db).filter(**self.core_filters)
                val = getattr(self.instance, attname)
                if ((val is None) or ((val == '') and connections[db].features.interprets_empty_strings_as_nulls)):
                    return qs.filter(pk__in=[])
                qs._known_related_objects = {
                    rel_field: {
                        self.instance.pk: self.instance,
                    },
                }
                return qs

        def get_prefetch_query_set(self, instances):
            rel_obj_attr = attrgetter(rel_field.attname)
            instance_attr = attrgetter(attname)
            instances_dict = dict(((instance_attr(inst), inst) for inst in instances))
            db = (self._db or router.db_for_read(self.model, instance=instances[0]))
            query = {
                ('%s__%s__in' % (rel_field.name, attname)): list(instances_dict),
            }
            qs = super(RelatedManager, self).get_query_set().using(db).filter(**query)
            for rel_obj in qs:
                instance = instances_dict[rel_obj_attr(rel_obj)]
                setattr(rel_obj, rel_field.name, instance)
            cache_name = rel_field.related_query_name()
            return (qs, rel_obj_attr, instance_attr, False, cache_name)

        def add(self, *objs):
            for obj in objs:
                if (not isinstance(obj, self.model)):
                    raise TypeError(("'%s' instance expected, got %r" % (self.model._meta.object_name, obj)))
                setattr(obj, rel_field.name, self.instance)
                obj.save()
        add.alters_data = True

        def create(self, **kwargs):
            kwargs[rel_field.name] = self.instance
            db = router.db_for_write(self.model, instance=self.instance)
            return super(RelatedManager, self.db_manager(db)).create(**kwargs)
        create.alters_data = True

        def get_or_create(self, **kwargs):
            kwargs[rel_field.name] = self.instance
            db = router.db_for_write(self.model, instance=self.instance)
            return super(RelatedManager, self.db_manager(db)).get_or_create(**kwargs)
        get_or_create.alters_data = True
        if rel_field.null:

            def remove(self, *objs):
                val = getattr(self.instance, attname)
                for obj in objs:
                    if (getattr(obj, rel_field.attname) == val):
                        setattr(obj, rel_field.name, None)
                        obj.save()
                    else:
                        raise rel_field.rel.to.DoesNotExist(('%r is not related to %r.' % (obj, self.instance)))
            remove.alters_data = True

            def clear(self):
                self.update(**{
                    rel_field.name: None,
                })
            clear.alters_data = True
    return RelatedManager

dataset/ETHPy150Open AppScale/appscale/AppServer/lib/django-1.5/django/db/models/fields/related.py ForeignRelatedObjectsDescriptor.related_manager_cls/original