XŽ@sdZddlmZddlZddlmZddlmZmZm Z ddl m Z m Z ddl mZddlmZdd lmZGd d d eZGd d d eZGdddeZddZGdddeZddZdS)aH Accessors for related objects. When a field defines a relation between two models, each model class provides an attribute to access related instances of the other model class (unless the reverse accessor has been disabled with related_name='+'). Accessors are implemented as descriptors in order to customize access and assignment. This module defines the descriptor classes. Forward accessors follow foreign keys. Reverse accessors trace them back. For example, with the following models:: class Parent(Model): pass class Child(Model): parent = ForeignKey(Parent, related_name='children') ``child.parent`` is a forward many-to-one relation. ``parent.children`` is a reverse many-to-one relation. There are three types of relations (many-to-one, one-to-one, and many-to-many) and two directions (forward and reverse) for a total of six combinations. 1. Related instance on the forward side of a many-to-one or one-to-one relation: ``ForwardManyToOneDescriptor``. Uniqueness of foreign key values is irrelevant to accessing the related instance, making the many-to-one and one-to-one cases identical as far as the descriptor is concerned. The constraint is checked upstream (unicity validation in forms) or downstream (unique indexes in the database). If you're looking for ``ForwardOneToOneDescriptor``, use ``ForwardManyToOneDescriptor`` instead. 2. Related instance on the reverse side of a one-to-one relation: ``ReverseOneToOneDescriptor``. One-to-one relations are asymmetrical, despite the apparent symmetry of the name, because they're implemented in the database with a foreign key from one table to another. As a consequence ``ReverseOneToOneDescriptor`` is slightly different from ``ForwardManyToOneDescriptor``. 3. Related objects manager for related instances on the reverse side of a many-to-one relation: ``ReverseManyToOneDescriptor``. Unlike the previous two classes, this one provides access to a collection of objects. It returns a manager rather than an instance. 4. Related objects manager for related instances on the forward or reverse sides of a many-to-many relation: ``ManyToManyDescriptor``. Many-to-many relations are symmetrical. The syntax of Django models requires declaring them on one side but that's an implementation detail. They could be declared on the other side without any change in behavior. Therefore the forward and reverse descriptors can be the same. If you're looking for ``ForwardManyToManyDescriptor`` or ``ReverseManyToManyDescriptor``, use ``ManyToManyDescriptor`` instead. )unicode_literalsN) attrgetter) connectionsrouter transaction)Qsignals)QuerySet)RemovedInDjango20Warning)cached_propertyc@sveZdZdZddZeddZddZdd Zd d d Z d d dZ ddZ d S)ForwardManyToOneDescriptora! Accessor to the related object on the forward side of a many-to-one or one-to-one relation. In the example:: class Child(Model): parent = ForeignKey(Parent, related_name='children') ``child.parent`` is a ``ForwardManyToOneDescriptor`` instance. cCs||_|jj|_dS)N)fieldget_cache_name cache_name)selfZfield_with_relrY/home/ubuntu/projects/ifolica/build/django/django/db/models/fields/related_descriptors.py__init__Xs z#ForwardManyToOneDescriptor.__init__cCs(ttd|jjjjtfiS)NRelatedObjectDoesNotExist)typestrr remote_fieldmodel DoesNotExistAttributeError)rrrrr\s z4ForwardManyToOneDescriptor.RelatedObjectDoesNotExistcCst||jS)N)hasattrr)rinstancerrr is_cachedgsz$ForwardManyToOneDescriptor.is_cachedcKs|jjj}t|jddrjt|jdds^tjdj|jj t dn|j}n |j }|j d|j S)Nuse_for_related_fieldsF*silence_use_for_related_fields_deprecationzQuse_for_related_fields is deprecated, instead set Meta.base_manager_name on '{}'.hints)r rrgetattr_default_managerwarningswarnformat_metalabelr _base_manager db_managerall)rr! related_modelmanagerrrr get_querysetjs    z'ForwardManyToOneDescriptor.get_querysetNc s^|dkr|j}n|jd|d|jj}|jjfdd|D}|jjd}|jjjst|jjdkrit fdd|Dd|j 6}ni|d|jj 6}|j |}|jjj sH|jjj}x1|D]&}|||} t||| qWn||d |jfS) Nrrcsi|]}||qSrr).0inst) instance_attrrr s zDForwardManyToOneDescriptor.get_prefetch_queryset..c3s|]}|dVqdS)rNr)r/r0)r1rr szCForwardManyToOneDescriptor.get_prefetch_queryset..z%s__inT)r. _add_hintsr get_foreign_related_valueget_local_related_valueforeign_related_fieldsrZ is_hiddenlensetnamerelated_query_namefiltermultiplersetattrr) r instancesqueryset rel_obj_attrinstances_dictZ related_fieldqueryrel_obj_cache_namerel_objrr)r1rget_prefetch_querysetzs"   *0 z0ForwardManyToOneDescriptor.get_prefetch_querysetc Cs(|dkr|Syt||j}Wntk r|jj|}d|kr]d}ng|jd|}|j|jj|}|j}|jj j st ||jj j |nt ||j|YnX|dkr |jj r |jd|jjj|jjfn|SdS)a= Get the related instance through the forward relation. With the example above, when getting ``child.parent``: - ``self`` is the descriptor managing the ``parent`` attribute - ``instance`` is the ``child`` instance - ``cls`` is the ``Child`` class (we don't need it) Nrz %s has no %s.)r"rrr r7r.r=Zget_reverse_related_filtergetrr>r?rnullrr__name__r;)rrclsrFvalqsrrr__get__s$     %z"ForwardManyToOneDescriptor.__get__cCs3|dk ret||jjjjj retd||jj|jj|jjjjjfn|dk r&|j j dkrt j |j d||j _ q&|j j dkrt j |j d||j _ q&|j j dk r&|j j dk r&t j||s#td|q#q&n|dkrt||jd}|dk rrt||jjjdnxl|jjD]\}}t||jdqWn<x9|jjD]+\}}t||jt||jqWt||j||dk r/|jjj r/t||jjj|ndS)aX Set the related instance through the forward relation. With the example above, when setting ``child.parent = parent``: - ``self`` is the descriptor managing the ``parent`` attribute - ``instance`` is the ``child`` instance - ``value`` is the ``parent`` instance on the right of the equal sign Nz4Cannot assign "%r": "%s.%s" must be a "%s" instance.rzGCannot assign "%r": the current database router prevents this relation.) isinstancer rrr'Zconcrete_model ValueError object_namer;_statedbr db_for_write __class__allow_relationr"rr?rrelated_fieldsattnamer>)rrvaluerelatedlh_fieldrh_fieldrrr__set__s4 +   !!$  #z"ForwardManyToOneDescriptor.__set__) rJ __module__ __qualname____doc__rr rrr.rGrNr]rrrrr Ks    )r c@sveZdZdZddZeddZddZdd Zd d d Z d d dZ ddZ d S)ReverseOneToOneDescriptora Accessor to the related object on the reverse side of a one-to-one relation. In the example:: class Restaurant(Model): place = OneToOneField(Place, related_name='restaurant') ``place.restaurant`` is a ``ReverseOneToOneDescriptor`` instance. cCs||_|j|_dS)N)rZrr)rrZrrrrs z"ReverseOneToOneDescriptor.__init__cCs%ttd|jjjtfiS)Nr)rrrZr,rr)rrrrrs z3ReverseOneToOneDescriptor.RelatedObjectDoesNotExistcCst||jS)N)rr)rrrrrr sz#ReverseOneToOneDescriptor.is_cachedcKs|jj}t|jddrgt|jdds[tjdj|jjt dn|j}n |j }|j d|j S)NrFrzQuse_for_related_fields is deprecated, instead set Meta.base_manager_name on '{}'.r r!) rZr,r"r#r$r%r&r'r(r r)r*r+)rr!r,r-rrrr.#s     z&ReverseOneToOneDescriptor.get_querysetNc s|dkr|j}n|jd|dt|jjj}ddfdd|D}i|d|jjj6}|j|}|jjj}x.|D]&}|||}t |||qW||d|j fS) NrrcSs |jS)N) _get_pk_val)objrrrr1:szFReverseOneToOneDescriptor.get_prefetch_queryset..instance_attrcsi|]}||qSrr)r/r0)r1rrr2=s zCReverseOneToOneDescriptor.get_prefetch_queryset..z%s__inT) r.r5rrZr rXr;r=rr?r) rr@rArBrCrDrErFrr)r1rrG3s   z/ReverseOneToOneDescriptor.get_prefetch_querysetcCs"|dkr|Syt||j}Wntk r|j}|dkrWd}nt|jjj|}y|jd|j|}Wn!|jj j k rd}YnXt ||jjj |t ||j|YnX|dkr|j d|jj|jjfn|SdS)a Get the related instance through the reverse relation. With the example above, when getting ``place.restaurant``: - ``self`` is the descriptor managing the ``restaurant`` attribute - ``instance`` is the ``place`` instance - ``cls`` is the ``Place`` class (unused) Keep in mind that ``Restaurant`` holds the foreign key to ``Place``. Nrz %s has no %s.)r"rrrbrZr Zget_forward_related_filterr.rHr,rr?rrrUrJget_accessor_name)rrrKrF related_pkZ filter_argsrrrrNIs*        z!ReverseOneToOneDescriptor.__get__c s|dkrcyt|j}Wntk r6YqXt|jt||jjjdnt||jj st d|j j |jj |jj j j fnFjjdkrtjjd|j_n|jjdkrtj|jd|j_nL|jjdk rdjjdk rdtj|sdt d|qdntfdd|jjjD}x:t|jjjD]#\}}t||j||qWt|j|t||jjjdS)a Set the related instance through the reverse relation. With the example above, when setting ``place.restaurant = restaurant``: - ``self`` is the descriptor managing the ``restaurant`` attribute - ``instance`` is the ``place`` instance - ``value`` is the ``restaurant`` instance on the right of the equal sign Keep in mind that ``Restaurant`` holds the foreign key to ``Place``. Nz4Cannot assign "%r": "%s.%s" must be a "%s" instance.rzGCannot assign "%r": the current database router prevents this relation.c3s!|]}t|jVqdS)N)r"rX)r/r )rrrr4sz4ReverseOneToOneDescriptor.__set__..)r"rrdelattrr?rZr r;rOr,rPr'rQrdrRrSrrTrUrVtupler8 enumeratelocal_related_fieldsrXr)rrrYrFreindexr r)rrr]xs4    !!$("z!ReverseOneToOneDescriptor.__set__) rJr^r_r`rr rrr.rGrNr]rrrrras    /rac@s[eZdZdZddZeddZdddZd d Zd d Z dS) ReverseManyToOneDescriptora Accessor to the related objects manager on the reverse side of a many-to-one relation. In the example:: class Child(Model): parent = ForeignKey(Parent, related_name='children') ``parent.children`` is a ``ReverseManyToOneDescriptor`` instance. Most of the implementation is delegated to a dynamically defined manager class built by ``create_forward_many_to_many_manager()`` defined below. cCs||_|j|_dS)N)relr )rrlrrrrs z#ReverseManyToOneDescriptor.__init__cCs"|jj}t|jj|jS)N)rlr,"create_reverse_many_to_one_managerr#rU)rr,rrrrelated_manager_clss  z.ReverseManyToOneDescriptor.related_manager_clsNcCs|dkr|S|j|S)a9 Get the related objects through the reverse relation. With the example above, when getting ``parent.children``: - ``self`` is the descriptor managing the ``children`` attribute - ``instance`` is the ``parent`` instance - ``cls`` is the ``Parent`` class (unused) N)rn)rrrKrrrrNs z"ReverseManyToOneDescriptor.__get__cCsd|jjfS)Nzreverse side of a related set)rlrd)rrrr_get_set_deprecation_msg_paramssz:ReverseManyToOneDescriptor._get_set_deprecation_msg_paramscCs@tjd|jtdd|j|}|j|dS)aa Set the related objects through the reverse relation. With the example above, when setting ``parent.children = children``: - ``self`` is the descriptor managing the ``children`` attribute - ``instance`` is the ``parent`` instance - ``value`` is the ``children`` sequence on the right of the equal sign zhDirect assignment to the %s is deprecated due to the implicit save() that happens. Use %s.set() instead. stacklevelr N)r$r%ror rNr:)rrrYr-rrrr]s   z"ReverseManyToOneDescriptor.__set__) rJr^r_r`rr rnrNror]rrrrrks    rkcs#Gfddd|S)z Create a manager for the reverse side of a many-to-one relation. This manager subclasses another manager, generally the default manager of the related model, and adds behaviors specific to many-to-one relations. csKeZdZfddZfddZdZddZfdd Zd fd d Zd dZ de _ fddZ de _ fddZ de _ fddZ de _ jjr2ddZde_ ddZde_ ddZde_ nddZde_ S)z:create_reverse_many_to_one_manager..RelatedManagercsNt|j||_j|_j|_i||jj6|_dS)N)superrrr,rr r; core_filters)rr)RelatedManagerrUrlrrrs    zCcreate_reverse_many_to_one_manager..RelatedManager.__init__cs:t|j|jd}t|j}||jS)Nr-)r"rpoprmrUr)rkwargsr- manager_class)rlrr__call__ szCcreate_reverse_many_to_one_manager..RelatedManager.__call__TcSs|jp!tj|jd|j}t|jj}|jd|j|jre|j |j}n|j |j }xQ|j j D]C}t|j|j}|dks|dkr|r|jSqWii|j|jj6|j 6|_|S)zX Filter the queryset for the instance this manager is bound to. rN)_dbrZ db_for_readrrrfeaturesZ!interprets_empty_strings_as_nullsr5usingr=rrr r8r"rXnonepkZ_known_related_objects)rrArSZempty_strings_as_nullr rLrrr_apply_rel_filterss$ #zMcreate_reverse_many_to_one_manager..RelatedManager._apply_rel_filtersc s\y|jj|jjSWn:ttfk rWt|j}|j|SYnXdS)N) r_prefetched_objects_cacher r<rKeyErrorrqr.r~)rrA)rsrUrrr."s zGcreate_reverse_many_to_one_manager..RelatedManager.get_querysetNc s|dkr$t|j}n|jd|d|j|jpM|j}|jj}|jjfdd|D}i|d|jj6}|j |}x4|D],}|||}t ||jj|qW|jj }||d|fS)Nrrcsi|]}||qSrr)r/r0)r1rrr22s zdcreate_reverse_many_to_one_manager..RelatedManager.get_prefetch_queryset..z%s__inF) rqr.r5r{ryr r7r6r;r=r?r<) rr@rArBrCrDrFrr)rsrU)r1rrG)s    zPcreate_reverse_many_to_one_manager..RelatedManager.get_prefetch_querysetc s6|jdd}t|}tjjdj}fdd}|rg}xY|D]Q}|||jjs|jj|krt d|n|j |j q^Wjj j |jd|jijjj6nDtjd|d d *x"|D]}|||jqWWdQXdS) NbulkTrcsQt|js4tdjjj|fnt|jjjdS)Nz'%s' instance expected, got %r) rOr TypeErrorr'rQr?r r;r)rc)rrrcheck_and_update_objCsz\create_reverse_many_to_one_manager..RelatedManager.add..check_and_update_objzA%r instance isn't saved. Use bulk=False or save the object first.pk__inr{ savepointF)rtlistrrTrrrRZaddingrSrPappendr}r)r{r=updater r;ratomicsave)robjsrurrSrZpksrcr)rradd>s&    $  z>create_reverse_many_to_one_manager..RelatedManager.addcsM|j||jj.RelatedManager.createcsM|j||jj.RelatedManager.get_or_createcsM|j||jj.RelatedManager.update_or_createc_s|s dS|jdd}|jj|j}t}x^|D]V}|jj||krr|j|jqA|jjj j d||jfqAW|j |j d||dS)NrTz%r is not related to %r.r) rtr r6rr:r7rr}rrr_clearr=)rrrurrLold_idsrcrrrremovers  zAcreate_reverse_many_to_one_manager..RelatedManager.removec[s&|jdd}|j||dS)NrT)rtr)rrurrrrclearsz@create_reverse_many_to_one_manager..RelatedManager.clearc Sstj|jd|j}|j|}|rM|jid|jj6n_tj d|ddEx=|D]5}t ||jjd|j d|jjgqmWWdQXdS)Nrr{rFZ update_fields) rrTrrr{rr r;rrr?r)rrArrSrcrrrrs zAcreate_reverse_many_to_one_manager..RelatedManager._clearc [s7t|}|jdd}|jdd}|jjr tj|jd|j}tj d|dd|r|j |j d||nt |j |j}g}x7|D]/}||kr|j|q|j|qW|jd|||j d||WdQXn|j d||dS)NrTrFrr{r)rgrtr rIrrTrrrrrrr:r{r+rr) rrrurrrSZold_objsnew_objsrcrrrr:s$     z>create_reverse_many_to_one_manager..RelatedManager.set)rJr^r_rrwdo_not_call_in_templatesr~r.rGr alters_datarrrr rIrrrr:r)rsrl)rUrrss.               rsr) superclassrlr)rsrlrrmsrmcs[eZdZdZdfddZeddZeddZd d Z S) ManyToManyDescriptora Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation. In the example:: class Pizza(Model): toppings = ManyToManyField(Topping, related_name='pizzas') ``pizza.toppings`` and ``topping.pizzas`` are ``ManyToManyDescriptor`` instances. Most of the implementation is delegated to a dynamically defined manager class built by ``create_forward_many_to_many_manager()`` defined below. Fcs#tt|j|||_dS)N)rqrrreverse)rrlr)rUrrrszManyToManyDescriptor.__init__cCs |jjS)N)rlthrough)rrrrrszManyToManyDescriptor.throughcCs@|jr|jjn |jj}t|jj|jd|jS)Nr)rrlr,r#create_forward_many_to_many_managerr#rU)rr,rrrrns !  z(ManyToManyDescriptor.related_manager_clscCs;d|jrdnd|jr.|jjn |jjfS)Nz%s side of a many-to-many setrZforward)rrlrdr r;)rrrrrosz4ManyToManyDescriptor._get_set_deprecation_msg_params) rJr^r_r`rpropertyrr rnrorr)rUrrs  rcs&Gfddd|S)z Create a manager for the either side of a many-to-many relation. This manager subclasses another manager, generally the default manager of the related model, and adds behaviors specific to many-to-many relations. csxeZdZdfddZfddZdZddZd d Zfd d Zdfd dZ fddZ de _ fddZ de _ fddZ de _ fddZde_ fddZde_ fddZde_ fddZde_ ddZfdd ZS)!z?create_forward_many_to_many_manager..ManyRelatedManagerNcst|j||_sj|_jj|_jj|_jj |_ jj |_ j |_ nZj|_jj|_jj|_jj |_ jj |_ d|_ j|_|_|jjj|j |_|jjj|j |_i|_xI|jjD];\}}d|j|jf}t||j|j|.ManyRelatedManager.__init__cs@t|j|jd}t|j}|d|jS)Nr-r)r"rrtrrUr)rrur-rv)rlrrrrwszHcreate_forward_many_to_many_manager..ManyRelatedManager.__call__TcSsti|j|j6}t|t p2|j}|r\|ti|d|j6M}n|jrti|j|j6}|r|ti|d|j6M}n||O}n|S)Nz%s__in)rrrrOr _has_filtersrr)rZ removed_valsfiltersZremoved_vals_filtersZsymmetrical_filtersrrr_build_remove_filters s !  zUcreate_forward_many_to_many_manager..ManyRelatedManager._build_remove_filterscSsG|jd|j|jr1|j|j}n|jj|jS)zX Filter the queryset for the instance this manager is bound to. r)r5rryr{_next_is_stickyr=rr)rrArrrr~0s zRcreate_forward_many_to_many_manager..ManyRelatedManager._apply_rel_filtersc sVy|jj|jSWn:ttfk rQt|j}|j|SYnXdS)N)rrrrrrqr.r~)rrA)rrUrrr.9s zLcreate_forward_many_to_many_manager..ManyRelatedManager.get_querysetcs|dkr$t|j}n|jd|d|j|jpM|j}i|d|j6}|jj|}|jj j |j |jj j t |jjj|jdfddjD}|fddfd dd |jfS) Nrrz%s__inselectcs9i|]/}d|jfd|jqS)z%s.%sz_prefetch_related_val_%s)columnrX)r/f) join_tableqnrrr2Vs zicreate_forward_many_to_many_manager..ManyRelatedManager.get_prefetch_queryset..cs tfddjDS)Nc3s%|]}td|jVqdS)z_prefetch_related_val_%sN)r"rX)r/r)resultrrr4[szzcreate_forward_many_to_many_manager..ManyRelatedManager.get_prefetch_queryset....)rgri)r)fk)rrZszgcreate_forward_many_to_many_manager..ManyRelatedManager.get_prefetch_queryset..cs#tfddjDS)Nc3s-|]#}|jt|jVqdS)N)Zget_db_prep_valuer"rX)r/r) connectionr0rrr4_szzcreate_forward_many_to_many_manager..ManyRelatedManager.get_prefetch_queryset....)rgr8)r0)rr)r0rr^sF)rqr.r5r{ryrrr=rr'rrZdb_tablerrSopsZ quote_nameextrarir)rr@rArD)rrU)rrrrrrG@s$     zUcreate_forward_many_to_many_manager..ManyRelatedManager.get_prefetch_querysetc sjjjs:|jj}td|j|jfntj|jd|j}t j d|ddC|j |j |j ||jr|j |j |j |nWdQXdS)NziCannot use add() on a ManyToManyField which specifies an intermediary model. Use %s.%s's Manager instead.rr{rF)rr' auto_createdr app_labelrQrrTrrr _add_itemsrrr)rroptsrS)rlrrrfs  zCcreate_forward_many_to_many_manager..ManyRelatedManager.addcsWjjjs:|jj}td|j|jfn|j|j|j|dS)NzlCannot use remove() on a ManyToManyField which specifies an intermediary model. Use %s.%s's Manager instead.) rr'rrrrQ _remove_itemsrr)rrr)rlrrrxs  zFcreate_forward_many_to_many_manager..ManyRelatedManager.removecs tj|jd|j}tjd|ddtjjd|jddd|jd|j d |j d dd||j t |j j|}|jjj|j|jtjjd|jdd d|jd|j d |j d dd|WdQXdS) Nrr{rFsenderactionZ pre_clearrrpk_setZ post_clear)rrTrrrrr m2m_changedsendrrrrqr.r{r#r=delete)rrSr)rrUrrrs '" zEcreate_forward_many_to_many_manager..ManyRelatedManager.clearc skjjjs:|jj}td|j|jfnt|}|jdd}tj |jd|j }t j d|dd|r|j |j|nt|j|j|jjjdd}g}xe|D]]}t||jr|jj|d n|} | |kr6|j| q|j|qW|j||j|WdQXdS) NzjCannot set values on a ManyToManyField which specifies an intermediary model. Use %s.%s's Manager instead.rFrr{rflatTr)rr'rrrrQrgrtrrTrrrrrr:r{ values_listrrXrOrr6rr) rrrurrrSrrrcfk_val)rlrrr:s*   - .  zCcreate_forward_many_to_many_manager..ManyRelatedManager.setcs|jjjs:|jj}td|j|jfntj|jj d|j}t |j |j |}|j ||S)NzlCannot use create() on a ManyToManyField which specifies an intermediary model. Use %s.%s's Manager instead.r)rr'rrrrQrrTrrUrqr*rr)rrurrSZnew_obj)rrUrrrs ! zFcreate_forward_many_to_many_manager..ManyRelatedManager.createcsetj|jjd|j}t|j|j|\}}|r[|j|n||fS)Nr)rrTrrUrqr*rr)rrurSrccreated)rrUrrrs 'zMcreate_forward_many_to_many_manager..ManyRelatedManager.get_or_createcsetj|jjd|j}t|j|j|\}}|r[|j|n||fS)Nr)rrTrrUrqr*rr)rrurSrcr)rrUrrrs 'zPcreate_forward_many_to_many_manager..ManyRelatedManager.update_or_createc sddlm}|rt}x|D]}t|jrtj|js~td|jj j |j j fnj j j j|d}|dkrtd|fn|j|q&t||rtdjj j|fq&|j|q&Wtjj dj}j jj|jddjijd6|d 6} |t| }tjd |d d jsjkrtjjd j dddjdjdjd|d |nj jj|jfdd|DjsLjkrtjjd j dddjdjdjd|d |nWdQXndS)Nr)ModelzHCannot add "%r": instance is on database "%s", value is on database "%s"z1Cannot add "%r": the value for field "%s" is Nonez'%s' instance expected, got %rrrTz%s__inr{rFrrZpre_addrrrcs<g|]2}jijdd6|d6qS)rz%s_id)rr)r/Zobj_id)rrrrr s z^create_forward_many_to_many_manager..ManyRelatedManager._add_items..Zpost_add) django.db.modelsrr:rOrrrVrrPrRrSrr'rr6rrrQrTr#r{rr=rrrrrrrrZ bulk_create) rrrrrZnew_idsrcrrSvalsr)rrrrrsT  %     zJcreate_forward_many_to_many_manager..ManyRelatedManager._add_itemsc s|s dSt}xS|D]K}t||jrX|jj|d}|j|q|j|qWtj|jd|j }t j d|ddt j jd|jddd|j d |jd |jd |d|t|j}|jr0|j|ji|d |jjj6} n|} |j| } |jjj|j| jt j jd|jdd d|j d |jd |jd |d|WdQXdS)Nrrr{rFrrZ pre_removerrrz%s__inZ post_remove)r:rOrrr6rrrTrrrrrrrrrqr.rr{r=rXrr#r) rrrrrrcrrSZtarget_model_qsZold_valsr)rrUrrr$s2    " zMcreate_forward_many_to_many_manager..ManyRelatedManager._remove_items)rJr^r_rrwrrr~r.rGrrrrr:rrrrrr)rrlr)rUrrs. ,  &   $     Err)rrlrr)rrlrrrs"ar)r` __future__rr$operatorrZ django.dbrrrrrrZdjango.db.models.queryr Zdjango.utils.deprecationr Zdjango.utils.functionalr objectr rarkrmrrrrrr=s E .