U
|
¸ý°dgq ã @ s d Z ddlmZ ddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
|
Z
|
dd lm Z dd
|
lm Z dd lm Z dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl m Z ddl m Z dd l m!Z! dd l m"Z" dd l m#Z# dd l m$Z$ dd l m%Z% dd!l m&Z& dd"l m'Z' dd#l m(Z( dd$l m)Z) dd%l m*Z* dd&l m+Z+ dd'l m,Z, dd(l m-Z- dd)l m.Z. dd*l m/Z/ dd+l m0Z0 dd,l m1Z1 dd-l m2Z2 dd.l m3Z3 dd/l m4Z4 dd0l m5Z5 dd1l m6Z6 dd2l m7Z7 dd3l m8Z8 dd4l m9Z9 dd5l m:Z: dd6l m;Z; dd7l m<Z< dd8l m=Z= dd9l m>Z> d:d;lm?Z? d:dlmZ d:d<lm@Z@ d:d=lmAZA d:d>l?mBZB d:d?l?mCZC d:d@lDm ZE d:dAlDmFZF d:dBlDmGZG d:dClDmHZH d:dDlDmIZI d:dElJmKZK d:dFlLmMZM d:dGlLmNZN d:dHlOmPZP d:dIlOmQZQ d:dJlOmRZR erddKlmSZS ddLlmTZT ddMlmUZU ddNlmVZV ddOlmWZW ddPlmXZX ddQlmYZY ddRlmZZZ ddSlm[Z[ ddTl\m]Z] ddUl^m_Z_ ddVlAm`Z` ddWlambZb d:dXlcmdZd d:dYlemfZf d:dZlemgZg d:d[lemhZh d:d\lemiZi d:d]ljmkZk d:d^llmmZm d:d_llmnZn d:d`lompZp d:dalqmrZr edbZseee dc e et f Zuet Zve@jwG ddde dee es e=es ejxejyes eHjzeHj{eEj|eFj}eAj~eC ZdfdgdhdidjdkdldmZG dndo doees ZejdpdqG drds dseKZdjdtdudvdwZeA
dx¡ZeA
dy¡ZeA
dz¡ZeA
d{¡ZeA
d|¡ZG d}d~ d~ZeZeZG dd dZG dd deZG dd deZG d
d dZerÜdddddZn
|
e d¡ZG dd deeZddfdddddZeA
d¡Zeee6ee/gZG dd de ZedddZe7fddfdddddZe7fdcdfdddddZdÑdgd¡dfddd¢d£d¤Zdd¥dgdfd¦dhd§djd¨d©dªd«ZdÒdgdfdd¬ddd§djdd® d¯d°Z dd¥d±dfd¦d²d§d¨d³d´dµZ¡d±dfdd¶d·d¸Z¢ddfd¹dºd»d¼Z£dcd½dfd¹d¾d¿dÀZ¤dÁd Z¥dÓddfdjdÃddÄdÅdÆZ¦ddfdjdÇdÈdÉZ§ddfddÇdÊdËZ¨ddfddÇdÌdÍZ©dddÎdÏdÐZªdS )ÔzÍDefines instrumentation for class attributes and their interaction
|
with instances.
|
|
This module is usually not directly visible to user applications, but
|
defines a large part of the ORM's interactivity.
|
|
|
é )Ú annotationsN)ÚAny)ÚCallable)Úcast)ÚClassVar)ÚDict)ÚList)Ú
|
NamedTuple)ÚOptional)Úoverload)ÚSequence)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Ú collections)Úexc)Ú
|
interfaces)Úinsp_is_aliased_class)Ú_DeclarativeMapped)Ú
|
ATTR_EMPTY)Ú ATTR_WAS_SET)Ú CALLABLES_OK)ÚDEFERRED_HISTORY_LOAD)ÚINIT_OK)Ú instance_dict©Úinstance_state)Ú instance_str)ÚLOAD_AGAINST_COMMITTED)ÚLoaderCallableStatus)Úmanager_of_class)ÚMapped)Ú NEVER_SET)Ú NO_AUTOFLUSH)Ú NO_CHANGE)ÚNO_KEY)ÚNO_RAISE)ÚNO_VALUE)ÚNON_PERSISTENT_OK)Úopt_manager_of_class)ÚPASSIVE_CLASS_MISMATCH)ÚPASSIVE_NO_FETCH)ÚPASSIVE_NO_FETCH_RELATED)ÚPASSIVE_NO_INITIALIZE)ÚPASSIVE_NO_RESULT)Ú PASSIVE_OFF)ÚPASSIVE_ONLY_PERSISTENT)ÚPASSIVE_RETURN_NO_VALUE)Ú PassiveFlag)ÚRELATED_OBJECT_OK)ÚSQL_OK)ÚSQLORMExpression)Ú state_stré )Úevent)Ú
|
inspection)Úutil)Ú
|
dispatcher)Ú EventTarget)Úbase)Ú cache_key)Ú coercions)Úroles)Úvisitors)Ú HasCacheKey)Ú_TraverseInternalsType)ÚInternalTraversal)ÚLiteral)ÚSelf)Ú TypeGuard)Ú _EntityType)Ú_ExternalEntityType)Ú _InstanceDict)Ú_InternalEntityType)Ú_LoaderCallable)Ú_O)Ú_AdaptedCollectionProtocol)ÚCollectionAdapter)ÚMapperProperty)ÚRelationshipProperty)Ú InstanceState)Ú AliasedInsp)ÚWriteOnlyAttributeImpl)Ú _Dispatch)Ú_ColumnExpressionArgument)Ú_DMLColumnArgument)Ú _InfoType)Ú_PropagateAttrsType)Ú_AnnotationDict)Ú ColumnElement)ÚLabel)Ú OperatorType)Ú
|
FromClauseÚ_TúInstanceState[Any]c @ s. e Zd ZU dZdZdZded< ded< ded < d
|
ed < d ed < ded< ded< ded< ded< dZdodddddddd d d Zd e j
|
j fd e j
|
j fde j
|
j fde j jfgZd d!d"d#Zed$d!d%d&Zefd d'd(d)d*d+Zed,d!d-d.Zd
|
ed/< d0ed1< d0d!d2d3Zd4d!d5d6Zed
|
d!d7d8Zed9d!d:d;Zd0d!d<d=Zed>d!d?d@Zd dAdBdCdDZ dEdFdGdHdIZ dJdKdLdMdNZ dOdPdQdRdSZ d dKdTdUdVZ ddWdXdYdZZ!d[d d d\d]d^d_Z"d[d d d\d]d`daZ#dpdcd$d$dddedfZ$dd dgdhdiZ%dd!djdkZ&dld!dmdnZ'dS )qÚQueryableAttributea« Base class for :term:`descriptor` objects that intercept
|
attribute events on behalf of a :class:`.MapperProperty`
|
object. The actual :class:`.MapperProperty` is accessible
|
via the :attr:`.QueryableAttribute.property`
|
attribute.
|
|
|
.. seealso::
|
|
:class:`.InstrumentedAttribute`
|
|
:class:`.MapperProperty`
|
|
:attr:`_orm.Mapper.all_orm_descriptors`
|
|
:attr:`_orm.Mapper.attrs`
|
) Úclass_ÚkeyÚimplÚ
|
comparatorÚpropertyÚparentÚ
|
expressionÚ_of_typeÚ_extra_criteriaZ_slots_dispatchZ_propagate_attrsÚ_docTz"dispatcher[QueryableAttribute[_T]]Údispatchú_ExternalEntityType[Any]re Ústrrf ú_InternalEntityType[Any]Ú parententityÚ AttributeImplrg ú interfaces.PropComparator[_T]rh z"Optional[_InternalEntityType[Any]]rl z Tuple[ColumnElement[bool], ...]rm ú Optional[str]rn Zorm_instrumented_attributeN© ú_ExternalEntityType[_O]ú_InternalEntityType[_O]zOptional[AttributeImpl])re rf rs rh rg Úof_typeÚextra_criteriac
|
C s || _ || _| | _| _|| _|d k s*t|| _|| _|| _d | _ t
|
|}|r|j D ]2} || krT| j | | j ¡ | | j jrTd| j _qTd S ©NT)re rf Ú _parententityrj rg ÚAssertionErrorrh rl rm rn r, Z_basesro Ú_updateÚ_active_history)
|
Úselfre rf rs rh rg rz r{ Úmanagerr@ rw rw úPd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/orm/attributes.pyÚ__init__Â s
|
|
zQueryableAttribute.__init__r} r ©Úreturnc C s t | j| jjj| j| jjffS ©N)Ú _queryable_attribute_unreducerf r} Zmapperre Úentity©r rw rw r Ú
|
__reduce__ï s üþz QueryableAttribute.__reduce__Úboolc C s | j jS r )rg Ú uses_objectsr rw rw r Ú_impl_uses_objectsü s z%QueryableAttribute._impl_uses_objectsr5 ÚHistory)ÚinstanceÚpassiver c C s | j t|t||¡S r )rg Ú get_historyr r )r r r rw rw r r s
|
ÿz QueryableAttribute.get_historyr[ c C s | j jS )a¬ Return the 'info' dictionary for the underlying SQL element.
|
|
The behavior here is as follows:
|
|
* If the attribute is a column-mapped property, i.e.
|
:class:`.ColumnProperty`, which is mapped directly
|
to a schema-level :class:`_schema.Column` object, this attribute
|
will return the :attr:`.SchemaItem.info` dictionary associated
|
with the core-level :class:`_schema.Column` object.
|
|
* If the attribute is a :class:`.ColumnProperty` but is mapped to
|
any other kind of SQL expression other than a
|
:class:`_schema.Column`,
|
the attribute will refer to the :attr:`.MapperProperty.info`
|
dictionary associated directly with the :class:`.ColumnProperty`,
|
assuming the SQL expression itself does not have its own ``.info``
|
attribute (which should be the case, unless a user-defined SQL
|
construct has defined one).
|
|
* If the attribute refers to any other kind of
|
:class:`.MapperProperty`, including :class:`.Relationship`,
|
the attribute will refer to the :attr:`.MapperProperty.info`
|
dictionary associated with that :class:`.MapperProperty`.
|
|
* To access the :attr:`.MapperProperty.info` dictionary of the
|
:class:`.MapperProperty` unconditionally, including for a
|
:class:`.ColumnProperty` that's associated directly with a
|
:class:`_schema.Column`, the attribute can be referred to using
|
:attr:`.QueryableAttribute.property` attribute, as
|
``MyClass.someattribute.property.info``.
|
|
.. seealso::
|
|
:attr:`.SchemaItem.info`
|
|
:attr:`.MapperProperty.info`
|
|
)rh Úinfor rw rw r r s (zQueryableAttribute.inforj zColumnElement[_T]rk c
|
C s¢ | j }t|tst| jtkr(d|i}n| j| j|d}| j ¡ }z t rVt|t
|
sVt|j }W n6 t k
|
r } zt d| |f ¡|W 5 d }~X Y n
|
X ||S d S )NÚentity_namespace)Ú proxy_keyZ proxy_ownerr z}When interpreting attribute "%s" as a SQL expression, expected __clause_element__() to return a ClauseElement object, got: %r)Ú_entity_namespaceÚ
|
isinstancerE r~ rf Ú_UNKNOWN_ATTR_KEYr} rh Ú__clause_element__r r^ Z _annotateÚAttributeErrorr ZInvalidRequestError)r r r ZceÚannoZaerw rw r Ú_memoized_attr_expressionD s,
|
|
ý
|
|
þÿüz,QueryableAttribute._memoized_attr_expressionr\ c C s t d| jd¡S )NZorm)Zcompile_state_pluginZplugin_subject)r= Z immutabledictZ _parentmapperr rw rw r Ú _memoized_attr__propagate_attrsf s
|
þÿz2QueryableAttribute._memoized_attr__propagate_attrsc C s | j S r )r} r rw rw r r q s z$QueryableAttribute._entity_namespacer] c C s
|
| ¡ jS r )r Ú _annotationsr rw rw r r u s z QueryableAttribute._annotationsc C s | j S r )rk r rw rw r r y s z%QueryableAttribute.__clause_element__zList[FromClause]c C s | j jS r )rk Ú _from_objectsr rw rw r r | s z QueryableAttribute._from_objectsz(Sequence[Tuple[_DMLColumnArgument, Any]]©Úvaluer c C s | j |¡S )z'Return setter tuples for a bulk UPDATE.)rh Ú_bulk_update_tuples©r r¡ rw rw r r¢ s z&QueryableAttribute._bulk_update_tupleszAliasedInsp[Any]rI )Úadapt_to_entityr c C s, | j r
|
t| j|j| j| j| j |¡|dS )N)rg rh rs )rl r~ Ú __class__r rf rg rh r¤ ©r r¤ rw rw r r¤ s
|
|
ûz"QueryableAttribute.adapt_to_entityz_EntityType[Any]zQueryableAttribute[_T])r r c C s. t | j| j| j| j| j |¡t |¡| j dS ©N©rg rh rz r{ )
|
rd re rf r} rg rh rz r< Úinspectrm )r r rw rw r rz s
|
ùzQueryableAttribute.of_typez _ColumnExpressionArgument[bool]zQueryableAttribute[bool])Úclausesr c G s\ t rt| jtjsttdd t |¡D }t | j
|
| j | j | j | jj| | j| j| dS )Nc s s | ]}t tj|¡V qd S r )rB ÚexpectrC ZWhereHavingRole)Ú.0Zclauserw rw r Ú <genexpr>¢ s ÿz*QueryableAttribute.and_.<locals>.<genexpr>r¨ )r r rh rT Z
|
Comparatorr~ Útupler= Zcoerce_generator_argrd re rf r} rg Úand_rl rm )r rª Úexprsrw rw r r¯ s þ
|
ùzQueryableAttribute.and_)Úkwr c K s$ t | j| j| j| j| j| j| jdS r§ )rd re rf r} rg rh rl rm ©r r± rw rw r Ú_clone± s ùzQueryableAttribute._clonez Label[_T])Únamer c C s | ¡ |¡S r )r Úlabel)r r´ rw rw r rµ ¼ s zQueryableAttribute.labelr` zColumnElement[Any])ÚopÚotherÚkwargsr c O s || j f||S r ©rh ©r r¶ r· r¸ rw rw r Úoperate¿ s zQueryableAttribute.operatec K s ||| j f|S r r¹ rº rw rw r Úreverse_operateÄ s z"QueryableAttribute.reverse_operateFrc ©ÚstateÚ
|
optimisticr c C s | j j||ddk S )N)r¿ F©rg Ú hasparent)r r¾ r¿ rw rw r rÁ É s z QueryableAttribute.hasparent)rf r c
|
C s zt j | |¡W S tk
|
r$ Y nX zt| j|W S tk
|
rz } z(tdt| jt| jj| |f |W 5 d }~X Y nX d S )NúFNeither %r object nor %r object associated with %s has an attribute %r©r= Ú MemoizedSlotsÚ __getattr__r Úgetattrrh ÚtypeÚ__name__)r rf Úerrrw rw r rÅ Î s$
|
üþÿ ÷z QueryableAttribute.__getattr__c C s | j j d| j S ©NÚ.©re rÈ rf r rw rw r Ú__str__â s zQueryableAttribute.__str__z Optional[MapperProperty[Any]]c C s | j jS r ©rh ri r rw rw r Ú_memoized_attr_propertyå s z*QueryableAttribute._memoized_attr_property)NNrw )F)(rÈ Ú
|
__module__Ú __qualname__Ú__doc__Ú __slots__Z is_attributeÚ__annotations__Z__visit_name__r rD ÚExtendedInternalTraversalÚ dp_stringÚdp_multirG Zdp_clauseelement_listÚ_cache_key_traversalr ri r r2 r r r r r r r r r¢ r¤ rz r¯ r³ rµ r» r¼ rÁ rÅ rÍ rÏ rw rw rw r rd sj
|
ø '
|
|
|
|
ü ÿ)
|
"
|
ÿrd rq zType[_O]ry rp r )rf Ú mapped_classrs r r c C s$ t |r| | ||¡S t|| S d S r )r Z_get_from_serializedrÆ )rf rÙ rs r rw rw r r é s r c s¾ e Zd ZdZdZdZejddddZejddd d
|
dZej dd fd d Zd d ddddZ
|
d ddddZ e dd ddddZ e d d ddddZ dd ddd dZ ZS ) ÚInstrumentedAttributez¤Class bound instrumented attribute which adds basic
|
:term:`descriptor` methods.
|
|
See :class:`.QueryableAttribute` for a description of most features.
|
|
|
rw Trv r
c C s | j S r ©rn r rw rw r rÒ s z InstrumentedAttribute.__doc__ÚNoner c C s
|
|| _ d S r rÛ r£ rw rw r rÒ s c s t jS r )ÚsuperrÒ )Úcls©r¥ rw r rÒ s Úobjectr )r r¡ r c C s | j t|t||d ¡ d S r )rg Úsetr r )r r r¡ rw rw r Ú__set__ s ÿz InstrumentedAttribute.__set__©r r c C s | j t|t|¡ d S r )rg Údeleter r )r r rw rw r Ú
|
__delete__ s z InstrumentedAttribute.__delete__úInstrumentedAttribute[_T])r Úownerr c C s d S r rw ©r r rç rw rw r Ú__get__ s z InstrumentedAttribute.__get__rb c C s d S r rw rè rw rw r ré ! s úOptional[object]z$Union[InstrumentedAttribute[_T], _T]c
|
C s~ |d kr | S t |}| jjr0| j|kr0|| j S z t|}W n. tk
|
rj } zt |¡|W 5 d }~X Y nX | j ||¡S d S r ) r rg Úsupports_populationrf r r Úorm_excZUnmappedInstanceErrorÚget)r r rç Údict_r¾ rÉ rw rw r ré % s
|
)rÈ rÐ rÑ rÒ rÓ Z inherit_cacher= Zrw_hybridpropertyÚsetterZ
|
classlevelrâ rå r ré Ú __classcell__rw rw rß r rÚ ÷ s rÚ T)Úfrozenc @ sR e Zd ZU dejfgZded< dZded< dZded< dZ ded < e
|
d
|
d Z d S ) ÚAdHocHasEntityNamespacer z ClassVar[_TraverseInternalsType]Ú_traverse_internals)r rr FzClassVar[bool]Ú is_mapperÚis_aliased_classc C s | j jS r )r r r rw rw r r B s z(AdHocHasEntityNamespace.entity_namespaceN) rÈ rÐ rÑ rG Zdp_has_cache_keyró rÔ rÓ rô rõ ri r rw rw rw r rò 6 s
|
ÿ rò z&Callable[..., QueryableAttribute[Any]])Ú
|
descriptorr c sB G fdddt t }t jd |_tj|t d d |S )z´Create an QueryableAttribute / user descriptor hybrid.
|
|
Returns a new QueryableAttribute type that delegates descriptor
|
behavior and getattr() to the given descriptor.
|
c s¶ e Zd ZdZdZd!ddZedd Zedd Zd
|
Z d e
|
j j fd e
|
j j fgZed d Zedd Zedd Zejdd Zdd Zdd Zdd Zdd d d Z fd d ZdS )"z'create_proxied_attribute.<locals>.ProxyzPresents the :class:`.QueryableAttribute` interface as a
|
proxy on top of a Python descriptor / :class:`.PropComparator`
|
combination.
|
|
rw Nc S s4 || _ || _|| _|| _|| _|| _| | _| _d S r )re rf rö Úoriginal_propertyÚ _comparatorÚ_adapt_to_entityrn rÒ )r re rf rö rh r¤ Údocr÷ rw rw r r ` s
|
z0create_proxied_attribute.<locals>.Proxy.__init__c S s t j| jddS ©NF)Zraiseerr©r< r© re r rw rw r r} r s z5create_proxied_attribute.<locals>.Proxy._parententityc S s t j| jddS rû rü r rw rw r rj v s z.create_proxied_attribute.<locals>.Proxy.parentTrf r} c S s | j d k ot| j| jjjS r )r÷ rÆ re rf rg r r rw rw r r s
|
þz:create_proxied_attribute.<locals>.Proxy._impl_uses_objectsc S s" t | jdr| jjS t| jS d S )Nr} )Úhasattrrø r} rò r rw rw r r s z9create_proxied_attribute.<locals>.Proxy._entity_namespacec S s | j jS r rÎ r rw rw r ri s z0create_proxied_attribute.<locals>.Proxy.propertyc S s0 t | jr| ¡ | _| jr*| j | j¡| _| jS r )Úcallablerø rù r¤ r rw rw r rh s
|
|
ÿz2create_proxied_attribute.<locals>.Proxy.comparatorc S s | |j| j| j| j|¡S r )r¥ r rf rö rø r¦ rw rw r r¤ s ûz7create_proxied_attribute.<locals>.Proxy.adapt_to_entityc [ s" | j | j| j| j| j| j| jdS )N)r¤ r÷ )r¥ re rf rö rø rù r÷ r² rw rw r r³ ¨ s úz.create_proxied_attribute.<locals>.Proxy._clonec S s, | j ||¡}|| j kr$|d kr$| S |S d S r )rö ré )r r rç Úretvalrw rw r ré ² s z/create_proxied_attribute.<locals>.Proxy.__get__rq r
c S s | j j d| j S rÊ rÌ r rw rw r rÍ ¼ s z/create_proxied_attribute.<locals>.Proxy.__str__c s zt j | |¡W S tk
|
r$ Y nX z t |W S tk
|
r } zº|dkrXtd|z
|
| j}W n< tk
|
r } z tdt j| |f |W 5 d}~X Y n^X zt||W W Y ¢LS tk
|
rú } z&tdt jt|j| |f |W 5 d}~X Y nX W 5 d}~X Y nX dS )zNDelegate __getattr__ to the original descriptor and/or
|
comparator.rh z[Neither %r object nor unconfigured comparator object associated with %s has an attribute %rNr rà )r Ú attributerÉ rh Zerr2Zerr3©rö rw r rÅ ¿ sB
|
|
þÿüüþÿ ÷z3create_proxied_attribute.<locals>.Proxy.__getattr__)NNN)rÈ rÐ rÑ rÒ rm r ri r} rj Z_is_internal_proxyrD rÕ rÖ r× rØ r r r= Zmemoized_propertyrh r¤ r³ ré rÍ rÅ rw r rw r ÚProxyS s6 ø
|
|
|
|
|
þ
|
|
|
|
|
|
r rö )r´ Z from_instance)rd r rÇ rÈ r= Z monkeypatch_proxied_specials)rö r rw r r Úcreate_proxied_attributeG s ÿr ZREMOVEÚAPPENDZREPLACEZ BULK_REPLACEZMODIFIEDc @ s8 e Zd ZdZdZdd Zdd Zedd Zd d
|
Z d S ) ÚAttributeEventTokenaï A token propagated throughout the course of a chain of attribute
|
events.
|
|
Serves as an indicator of the source of the event and also provides
|
a means of controlling propagation across a chain of attribute
|
operations.
|
|
The :class:`.Event` object is sent as the ``initiator`` argument
|
when dealing with events such as :meth:`.AttributeEvents.append`,
|
:meth:`.AttributeEvents.set`,
|
and :meth:`.AttributeEvents.remove`.
|
|
The :class:`.Event` object is currently interpreted by the backref
|
event handlers, and is used to control the propagation of operations
|
across two mutually-dependent attributes.
|
|
.. versionchanged:: 2.0 Changed the name from ``AttributeEvent``
|
to ``AttributeEventToken``.
|
|
:attribute impl: The :class:`.AttributeImpl` which is the current event
|
initiator.
|
|
:attribute op: The symbol :attr:`.OP_APPEND`, :attr:`.OP_REMOVE`,
|
:attr:`.OP_REPLACE`, or :attr:`.OP_BULK_REPLACE`, indicating the
|
source operation.
|
|
©rg r¶ Ú parent_tokenc C s || _ || _| j j| _d S r r )r Zattribute_implr¶ rw rw r r s z AttributeEventToken.__init__c C s" t |to |j| jko |j| jkS r )r r rg r¶ )r r· rw rw r Ú__eq__ s
|
|
|
ÿ
|
ýzAttributeEventToken.__eq__c C s | j jS r )rg rf r rw rw r rf # s zAttributeEventToken.keyc C s | j |¡S r rÀ )r r¾ rw rw r rÁ ' s z AttributeEventToken.hasparentN)
|
rÈ rÐ rÑ rÒ rÓ r r ri rf rÁ rw rw rw r r ø s
|
r c @ sê e Zd ZU dZded< ded< ded< ded< ded< dZd ed
|
< d ed < d ed < dKddddddddddddd ddZdZddd d Zd d Z d d! Z
|
e e e
|
Z dLd"ddd#d$d%Z d"d"dd&d'd(d)Zefd"d*d+d,d-d.d/Zefd"d*d+d0d-d1d2Zd"d*dd3d4d5Zefd"d*d+dd-d6d7Zd"dd+dd8d9d:Zefd"d*ddd+d&d;d<d=Zefd"d*ddd+d&d;d>d?Zefd"d*ddd+d&d;d@dAZd ed dfd"d*ddd+ddd&dBdCdDZd"d*d&d3dEdFZefd"d*d+dd-dGdHZdIdJ Z d S )Mrt z4internal implementation for instrumented attributes.r Ú
|
collectionÚ default_accepts_scalar_loaderr rë ÚdynamicFr Ú_replace_tokenÚ _remove_tokenÚ _append_tokenNTrx rq rO ú"_Dispatch[QueryableAttribute[Any]]z Optional[Callable[..., bool]]ú Optional[AttributeEventToken]zOptional[bool]r ) re rf Ú callable_ro Ú trackparentÚcompare_functionÚactive_historyr Úload_on_unexpireÚsend_modified_eventsÚaccepts_scalar_loaderr¸ c K s || _ || _|| _|| _|| _|p$| | _|
|
| _|dkr@tj| _ n|| _ | dk rV| | _
|
n| j | _
|
| dd¡} | | _ |r|d| j_| | _t| t| _dS )aº Construct an AttributeImpl.
|
|
:param \class_: associated class
|
|
:param key: string name of the attribute
|
|
:param \callable_:
|
optional function which generates a callable based on a parent
|
instance, which produces the "default" values for a scalar or
|
collection attribute when it's first accessed, if not present
|
already.
|
|
:param trackparent:
|
if True, attempt to track if an instance has a parent attached
|
to it via this attribute.
|
|
:param compare_function:
|
a function that compares two values which are normally
|
assignable to this attribute.
|
|
:param active_history:
|
indicates that get_history() should always return the "old" value,
|
even if it means executing a lazy callable upon attribute change.
|
|
:param parent_token:
|
Usually references the MapperProperty, used as a key for
|
the hasparent() function to identify an "owning" attribute.
|
Allows multiple AttributeImpls to all match a single
|
owner attribute.
|
|
:param load_on_unexpire:
|
if False, don't include this attribute in a load-on-expired
|
operation, i.e. the "expired_attribute_loader" process.
|
The attribute can still be in the "expired" list and be
|
considered to be "expired". Previously, this flag was called
|
"expire_missing" and is only used by a deferred column
|
attribute.
|
|
:param send_modified_events:
|
if False, the InstanceState._modified_event method will have no
|
effect; this means the attribute will never show up as changed in a
|
history entry.
|
|
NÚ_deferred_historyFT)re rf r ro r r r ÚoperatorÚeqÚis_equalr r
|
Úpopr r r r Ú OP_MODIFIEDÚ_modified_token)r re rf r ro r r r r r r r r¸ r rw rw r r > s& ;
|
|
zAttributeImpl.__init__) re rf r ro r r r r r r r r r
c C s | j j d| j S rÊ rÌ r rw rw r rÍ ¢ s zAttributeImpl.__str__c C s | j jS )z(Backwards compat for impl.active_history©ro r r rw rw r Ú_get_active_history¥ s z!AttributeImpl._get_active_historyc C s || j _d S r r r£ rw rw r Ú_set_active_historyª s z!AttributeImpl._set_active_historyrc r½ c C s* d}| j st||j t| j|¡dk S )a4 Return the boolean value of a `hasparent` flag attached to
|
the given state.
|
|
The `optimistic` flag determines what the default return value
|
should be if no `hasparent` flag can be located.
|
|
As this function is used to determine if an instance is an
|
*orphan*, instances that were loaded from storage should be
|
assumed to not be orphans, until a True/False value for this
|
flag is set.
|
|
An instance attribute that is loaded by a callable function
|
will also not have a `hasparent` flag.
|
|
ú6This AttributeImpl is not configured to track parents.F)r r~ Úparentsrí Úidr )r r¾ r¿ Úmsgrw rw r rÁ ¯ s ÿzAttributeImpl.hasparentrÜ )r¾ Ú parent_stater¡ r c C s d}| j st|t| j}|r,||j|< n`||jkr|j| }|dk r|j|jkr| ¡ dkr~t dt |t || jf ¡dS d|j|< dS )zÁSet a boolean flag on the given item corresponding to
|
whether or not it is attached to a parent object via the
|
attribute represented by this ``InstrumentedAttribute``.
|
|
r" FNzRemoving state %s from parent state %s along attribute '%s', but the parent record has gone stale, can't be sure this is the most recent parent.)
|
r r~ r$ r r# rf Úobjrì ZStaleDataErrorr9 )r r¾ r& r¡ r% Zid_Z last_parentrw rw r Ú sethasparentÈ s,
|
|
|
ÿ
|
þ ýûÿ zAttributeImpl.sethasparentrM r5 r ©r¾ rî r r c C s
|
t d S r ©ÚNotImplementedError©r r¾ rî r rw rw r r ô s zAttributeImpl.get_historyÚ_AllPendingTypec C s
|
t dS )a¦ Return a list of tuples of (state, obj)
|
for all objects in this attribute's current state
|
+ history.
|
|
Only applies to object-based attributes.
|
|
This is an inlining of existing functionality
|
which roughly corresponds to:
|
|
get_state_history(
|
state,
|
key,
|
passive=PASSIVE_NO_INITIALIZE).sum()
|
|
Nr* r, rw rw r Úget_all_pendingü s z AttributeImpl.get_all_pending©r¾ rî r c C s@ | j |kstdd}| jjD ] }||||}|tk r |}q |S )z=Produce an empty value for an uninitialized scalar attribute.úO_default_value should only be invoked for an uninitialized or expired attributeN)rf r~ ro Z init_scalarr )r r¾ rî r¡ ÚfnÚretrw rw r Ú_default_value s ÿ z AttributeImpl._default_valuec
|
C sØ | j |kr|| j S | j }||jks2|j| tkr¼|t@ s>tS | |||¡}|tks\|tkr`|S |tkr¦z
|
|| W S tk
|
r¢ } ztd| |W 5 d}~X Y q¼X n|tk r¼| |||¡S |t
|
@ sÈtS | ||¡S dS )züRetrieve a value from the given object.
|
If a callable is assembled on this object's attribute, and
|
passive is False, the callable will be executed and the
|
resulting value will be set as the new value for this attribute.
|
z=Deferred loader for attribute %r failed to populate correctlyN) rf Úcommitted_stater* r r1 Ú_fire_loader_callablesr ÚKeyErrorr Úset_committed_valuer r3 )r r¾ rî r rf r¡ rÉ rw rw r rí % s8
|
|
ÿ þ
|
þÿüzAttributeImpl.get©r¾ rf r r c C sZ | j r"| jr"||jkr"| ||¡S ||jkr@|j| }|||S | jrR| ||¡S tS d S r )r r Úexpired_attributesZ _load_expiredZ callablesr r )r r¾ rf r r rw rw r r5 R s ÿþý
|
|
|
z$AttributeImpl._fire_loader_callables©r¾ rî r¡ Ú initiatorr r c C s | j |||||d d S ©N©r ©rá ©r r¾ rî r¡ r; r rw rw r Úappendc s zAttributeImpl.appendc C s | j ||d |||d d S )N)r Ú check_oldr> r? rw rw r Úremovem s ÿzAttributeImpl.removec C s | j ||d |||dd d S )NT)r rA r r> r? rw rw r r y s ùzAttributeImpl.pop©r¾ rî r¡ r; r rA r r c C s
|
t d S r r* )r r¾ rî r¡ r; r rA r rw rw r rá s
|
zAttributeImpl.setc C s
|
t d S r r* )r r¾ rî rw rw r rä s zAttributeImpl.deletec C s> | j |jkr*|j| j }|tkr$dS |S n| j|||dS dS )z,return the unchanged value of this attributeNr= )rf r4 r* rí )r r¾ rî r r¡ rw rw r Úget_committed_value s z!AttributeImpl.get_committed_valuec C s ||| j < | || j g¡ |S )z=set an attribute value on the given instance and 'commit' it.)rf Ú_commit)r r¾ rî r¡ rw rw r r7 « s
|
z!AttributeImpl.set_committed_value)FNFNTTN)F) rÈ rÐ rÑ rÒ rÔ Ú_is_has_collection_adapterr rÓ rÍ r r! ri r rÁ r( r2 r r0 r. r3 rí r5 r@ rB r rá rä rD r7 rw rw rw r rt / sb
|
ô&U
|
ÿ0ü üü-úúúø ürt c
|
s¶ e Zd ZdZdZdZdZdZdZdZ fddZ
|
ddd d
|
d d Z e fdd dddddZ de ddfdd dddddd dddZddddddd d d Zddddd d d d!Z ZS )"ÚScalarAttributeImplz8represents a scalar value-holding InstrumentedAttribute.TF)r r r c s0 t j|| t| t | _| _t| t| _d S r )rÝ r r Ú
|
OP_REPLACEr r Ú OP_REMOVEr )r Úargr± rß rw r r ¾ s ÿ z ScalarAttributeImpl.__init__rc rM rÜ r/ c C s | j jr| ||t¡}n| | jt¡}| j jr@| |||| j¡ | || |¡ |
|
| jt¡}|tkr|tkr|j s| j|j krt d| d S )Nú %s object does not have a value)ro r rí r4 rf r* rB Úfire_remove_eventr Ú_modified_eventr Zexpiredr9 r ©r r¾ rî ÚoldÚexistingrw rw r rä Å s ÿþý
|
üzScalarAttributeImpl.deletezDict[str, Any]r5 r r) c C sv | j |kr t | ||| j ¡S | j |jkr8t | |t¡S |t@ rH|tN }| j|||d}|tkrdtS t | ||¡S d S r< ) rf r Úfrom_scalar_attributer4 r* r rí r1 Ú HISTORY_BLANK©r r¾ rî r Úcurrentrw rw r r Ø s
|
z ScalarAttributeImpl.get_historyNr r rê r rC c C s\ | j jr| ||t¡}n| | jt¡}| j jr@| |||||¡}| || |¡ ||| j< d S r ) ro r rí r4 rf r* rá Úfire_replace_eventrM © r r¾ rî r¡ r; r rA r rO rw rw r rá ë s
|
ÿzScalarAttributeImpl.setrb ©r¾ rî r¡ Úpreviousr; r c C s& | j jD ]}|||||p | j}q|S r )ro rá r ©r r¾ rî r¡ rX r; r1 rw rw r rU s ÿz&ScalarAttributeImpl.fire_replace_event©r¾ rî r¡ r; r c C s$ | j jD ]}||||p| j qd S r )ro rB r ©r r¾ rî r¡ r; r1 rw rw r rL s z%ScalarAttributeImpl.fire_remove_event)rÈ rÐ rÑ rÒ r
|
r rë r r rÓ r rä r2 r rá rU rL rð rw rw rß r rG ³ s$ üø rG c
|
@ sº e Zd ZdZdZdZdZdZdZddddd d
|
Z e
|
fddd d d ddZ e fddd dd ddZ de
|
ddfddddd ddddddZdddddddd Zddd ddd d d d ZdS )!ÚScalarObjectAttributeImplzrepresents a scalar-holding InstrumentedAttribute,
|
where the target object is also instrumented.
|
|
Adds events to delete/set operations.
|
|
FTrw rc rM rÜ r/ c C s | j jr"| j||ttB tB d}n | j||ttA tB tB d}| |||| j
|
¡ | | j t ¡}|t kr|tk r|j d krtd| d S )Nr= rK )ro r rí r3 r& r! r. r r) rL r r rf r* r1 r rN rw rw r rä ) s8 ÿþýÿþýÿþýz ScalarObjectAttributeImpl.deleter5 r r) c C s¬ | j |kr|| j }n,|t@ r&|tN }| j|||d}|tkrBtS | jsVt | ||¡S |j | j t ¡}|tkr|t
|
t B t B t B tB B }| || j |¡}tj| |||dS d S )Nr= )Úoriginal)rf r rí r1 rR r r Úfrom_object_attributer4 Ú _NO_HISTORYr3 r& r! r) r r5 )r r¾ rî r rT r] Zloader_passiverw rw r r I sB
|
ÿþýüÿ ÿ ÿz%ScalarObjectAttributeImpl.get_historyr- c C s° | j |kr|| j }n |t@ r0| j|||d}ng S |d k r\|tk r\|tk r\t||fg}ndg}| j |jkr¬|j| j }|d k r¬|tk r¬|tk r¬||k r¬| t||f¡ |S )Nr= )NN)rf r rí r1 r* r r4 r@ )r r¾ rî r rT r2 r] rw rw r r. l s2
|
ÿþý ÿþýüz)ScalarObjectAttributeImpl.get_all_pendingNr r r rC c C s | j jr"| j||ttB tB d}n | j||ttA tB tB d}|dk rz|t k rz||k rz|r^dS t
|
dt |t || j f | |||||¡}||| j < dS )z'Set a value on the given InstanceState.r= Nz2Object %s not associated with %s on attribute '%s')ro r rí r3 r& r! r. r r) r1 Ú
|
ValueErrorr r9 rf rU rV rw rw r rá sD ÿþýÿþý ÿþýÿÿz ScalarObjectAttributeImpl.setrZ c C sX | j r&|d ttfkr&| t||d¡ | jjD ]}||||p@| j q.| || |¡ d S )NF) r r1 r* r( r ro rB r rM r[ rw rw r rL ¾ s ý z+ScalarObjectAttributeImpl.fire_remove_eventrb rW c C s | j r.||k r.|d ttfkr.| t||d¡ | jjD ]}|||||pJ| j}q6| || |¡ | j r~|d k r~| t||d¡ |S )NFT) r r1 r* r( r ro rá r rM rY rw rw r rU Ñ s&
|
ý ÿz,ScalarObjectAttributeImpl.fire_replace_event)rÈ rÐ rÑ rÒ r
|
r rë r rÓ rä r2 r r0 r. rá rL rU rw rw rw r r\ s$ $ü'ü*ø -r\ c @ sÒ e Zd ZU dZded< dZdddddd d
|
d Zed dd ddddddZed!dd ddddddZed"dd ddddddZde j
|
fdd ddddddZde j
|
dddfdd dd dddddd d d Z dS )#ÚHasCollectionAdapterrw r r Trc rQ rR rÜ ©r¾ r ÚadapterÚ
|
fire_eventr c C s
|
t d S r r* ©r r¾ r rc rd rw rw r Ú _dispose_previous_collectionõ s z1HasCollectionAdapter._dispose_previous_collection.rM ú Literal[None]ú Literal[PassiveFlag.PASSIVE_OFF]©r¾ rî Ú user_datar r c C s d S r rw ©r r¾ rî rj r rw rw r Úget_collectionþ s z#HasCollectionAdapter.get_collectionr5 c C s d S r rw rk rw rw r rl s ú$Optional[_AdaptedCollectionProtocol]úIUnion[Literal[LoaderCallableStatus.PASSIVE_NO_RESULT], CollectionAdapter]c C s d S r rw rk rw rw r rl s
|
Nc C s
|
t d S r r* rk rw rw r rl s Fr r © r¾ rî r¡ r; r rA r Ú_adaptr c C s
|
t d S r r* ) r r¾ rî r¡ r; r rA r rp rw rw r rá ) s zHasCollectionAdapter.set)..)..)..) rÈ rÐ rÑ rÓ rÔ rF rf r rl r5 r2 rá rw rw rw r ra ï s2
|
û û ûû÷ra z"TypeGuard[CollectionAttributeImpl])rg r c C s d S r rw )rg rw rw r Ú _is_collection_attribute_impl9 s rq r c s< e Zd ZU dZdZdZdZdZdZde d< dZ
|
dO fdd Z d
|
d Z e fd d dddddZefd d dddddZd d dddddddZd d dddddd d Zd d ddd d d d!Zd d d"ddd dd#d$Zd d d d%d&d'Zd d d(d%d)d*Zd d+d,d-d.Ze fd d d"ddd d/d0d1Ze fd d d"ddd d/d2d3Ze fd d d"ddd d/d4d5Zdej dddfd d d"ddd"d6d6d d7 d8d9Z d d(d:d6d d;d<d=Z d(d d>d?d@Z d d d"d(dAdBdCZ e dPd d dEdFd:dGdHdIZ!e dQd d d(dd:dGdJdIZ!e dDe fd d dKddLdGdMdIZ!de fd d dKddLdGdNdIZ! Z"S )RÚCollectionAttributeImpla« A collection-holding attribute that instruments changes in membership.
|
|
Only handles collections of instrumented objects.
|
|
InstrumentedCollectionAttribute holds an arbitrary, user-specified
|
container object (defaulting to a list) and brokers access to the
|
CollectionAdapter, a "view" onto that object that presents consistent bag
|
semantics to the orm layer independent of the user data implementation.
|
|
TFr Ú_bulk_replace_token)ÚcopyÚcollection_factoryr r rs Ú_duck_typed_asNc s¨ t j||||f||d| |d kr.| j}|| _|| _t| t| _t| t| _ t| t
|
| _ t | ¡ ¡| _t| jdd r¤t | d¡dd }
|
t | d¡dd } d S ) N)r r Ú
|
_sa_linkerÚinit_collectionc S s | |¡ d S r ©rw ©Útargetr Úcollection_adapterrw rw r Úlink s z.CollectionAttributeImpl.__init__.<locals>.linkÚdispose_collectionc S s | d ¡ d S r ry rz rw rw r Úunlink s z0CollectionAttributeImpl.__init__.<locals>.unlink)rÝ r Ú _CollectionAttributeImpl__copyrt ru r Ú OP_APPENDr rI r ÚOP_BULK_REPLACErs r= Úduck_type_collectionrv rÆ r; Z listens_for) r re rf r ro Ú typecallabler Ú copy_functionr r¸ r} r rß rw r r _ s4 üúù
|
ÿ
|
|
|
z CollectionAttributeImpl.__init__c C s dd t |¡D S )Nc S s g | ]}|qS rw rw )r¬ Úyrw rw r Ú
|
<listcomp> s z2CollectionAttributeImpl.__copy.<locals>.<listcomp>)r r| )r Úitemrw rw r Z__copy s z CollectionAttributeImpl.__copyrc rM r5 r r) c C s. | j |||d}|tkr tS t | ||¡S d S r< )rí r1 rR r Úfrom_collectionrS rw rw r r s z#CollectionAttributeImpl.get_historyr- c s² | j |krg S || j }t|d}| j |jkr¤|j| j }|tk r¤dd |D }dd |D }t| t|fdd|D fdd|D fdd|D S dd |D S ) NÚ _sa_adapterc S s$ g | ] }|d k rt |pd |fqS r r ©r¬ Úcrw rw r r ª s ÿz;CollectionAttributeImpl.get_all_pending.<locals>.<listcomp>c S s$ g | ] }|d k rt |pd |fqS r r r rw rw r r ® s ÿc s g | ]\}}| kr||fqS rw rw ©r¬ ÚsÚo©Ú original_setrw r r · s þc s g | ]\}}| kr||fqS rw rw r r rw r r ¼ s c s g | ]\}}| kr||fqS rw rw r ©Ú current_setrw r r ½ s þc S s g | ]}t ||fqS rw r )r¬ r rw rw r r Ä s )rf rÆ r4 r* Údict)r r¾ rî r rT r] Úcurrent_statesÚoriginal_statesrw ©r r r r. s4
|
|
|
þþ
|
þû
|
þúÿz'CollectionAttributeImpl.get_all_pendingrb r z Optional[Any])r¾ rî r¡ r; rf r c C sX | j jD ]}||||p| j|d}q| || td¡ | jrT|d k rT| t||d¡ |S )N©rf T)ro r@ r rM r* r r( r ©r r¾ rî r¡ r; rf r1 rw rw r Úfire_append_eventÆ s z)CollectionAttributeImpl.fire_append_eventc C s( | j jD ]}||||p| j|d}q|S )Nr )ro Zappend_wo_mutationr r rw rw r Ú fire_append_wo_mutation_eventØ s z5CollectionAttributeImpl.fire_append_wo_mutation_eventrÜ )r¾ rî r; rf r c C s | || td¡ dS )af A special event used for pop() operations.
|
|
The "remove" event needs to have the item to be removed passed to
|
it, which in the case of pop from a set, we don't have a way to access
|
the item before the operation. the event is used for all pop()
|
operations (even though set.pop is the one where it is really needed).
|
|
TN)rM r* )r r¾ rî r; rf rw rw r Úfire_pre_remove_eventå s z-CollectionAttributeImpl.fire_pre_remove_eventr c C sX | j r |d k r | t||d¡ | jjD ]}||||p:| j|d q(| || td¡ d S )NFr T)r r( r ro rB r rM r* r rw rw r rL ö s
|
z)CollectionAttributeImpl.fire_remove_eventr/ c C s@ | j |krd S | || td¡ | ||j¡}| ¡ || j = d S r| )rf rM r* rl r Zclear_with_event)r r¾ rî r rw rw r rä s
|
z CollectionAttributeImpl.deleterQ c C sF | j |kstd| j |jkr*|j| j S | |¡\}}| |¡ |S )z;Produce an empty collection for an un-initialized attributer0 )rf r~ Ú_empty_collectionsÚ_initialize_collectionZ
|
_set_empty)r r¾ rî rc rj rw rw r r3 s ÿ
|
z&CollectionAttributeImpl._default_valuez4Tuple[CollectionAdapter, _AdaptedCollectionProtocol])r¾ r c C s0 |j | j|| j¡\}}| j |||¡ ||fS r )r Zinitialize_collectionrf ru ro rx )r r¾ rc r rw rw r r $ s ÿz.CollectionAttributeImpl._initialize_collectionr: c C sv | j ||d |d}|tkrT| j||||td}| j|ks@td| | j¡ |¡ n trft |t
|
sft| ||¡ d S ©N)rj r r z,Collection was loaded during event handling.) rl r1 r r( rf r~ Ú_get_pending_mutationr@ r r rR Zappend_with_event©r r¾ rî r¡ r; r r rw rw r r@ 0 s, ÿ ÿÿþz CollectionAttributeImpl.appendc C sx | j ||jd |d}|tkrV| j||||td | j|ksBtd| | j¡ |¡ n t rht
|
|t sht| ||¡ d S r ) rl r r1 rL r( rf r~ r rB r r rR Zremove_with_eventr¡ rw rw r rB H s ÿÿþz CollectionAttributeImpl.removec
|
C s8 z| j |||||d W n tttfk
|
r2 Y nX d S r< )rB r` r6 Ú
|
IndexErrorr? rw rw r r ^ s zCollectionAttributeImpl.popr ro c C sn | } }
|
d } | |¡\} } |r°| jd k r4| | ¡} qÆt | ¡}| j}||k rx| d krXdp^| jj}| jj}td||f t| dr| ¡ } qÆ|t
|
kr¦t | } | ¡ } qÆt | } nt | ¡t
|
krÆt |} t | }| j}| jj|||| d | j||t|tj@ A d}|tkr| ||¡}n||
|
kr(d S | || |d¡ |j}| || j< tj||| |d | |||d¡ d S )NrÜ z/Incompatible collection type: %s is not %s-likeÚ _sa_iterator)Úkeysr= T)r; ) r Z
|
_converterr= r rv r¥ rÈ Ú TypeErrorrý r£ r ÚlistÚvaluesÚiterrs ro Z bulk_replacerí r3 r5 r) r1 r3 rM r rf r rf )r r¾ rî r¡ r; r rA r rp ÚiterableZ orig_iterableZnew_keysZnew_collectionrj Z setting_typeZreceiving_typeÚgivenÚwantedZ
|
new_valuesZevtrO Úold_collectionrw rw r rá n sd
|
|
ÿýÿÿ
|
|
|
|
ý
|
|
|
ÿzCollectionAttributeImpl.setrR rb c C s, |` |j | jd ¡ |r(| j |||¡ d S r )r r r rf ro r~ re rw rw r rf ¿ s z4CollectionAttributeImpl._dispose_previous_collection)r r c C s t |d}d|_d S )Nr T)rÆ Z invalidated)r r rc rw rw r Ú_invalidate_collectionÎ s
|
z.CollectionAttributeImpl._invalidate_collection)r¾ rî r¡ r c
|
C s | |¡\}}|r | |¡ ||j| j< | || jg¡ | j|jkr| || |d¡ |j | j¡}|j}|j }|D ]} |
|
| ¡ qr|D ]} | | ¡ q|S )z=Set an attribute value on the given instance and 'commit' it.T) r Z append_multiple_without_eventr rf rE Z_pending_mutationsrM r Z added_itemsZ deleted_itemsZappend_without_eventZremove_without_event)
|
r r¾ rî r¡ r rj ÚpendingÚaddedÚremovedr rw rw r r7 Ô s
|
z+CollectionAttributeImpl.set_committed_value.rg rh ri c C s d S r rw rk rw rw r rl ñ s z&CollectionAttributeImpl.get_collectionc C s d S r rw rk rw rw r rl û s rm rn c C s d S r rw rk rw rw r rl s
|
c C s6 |dkr0| j |||d}|tjkr&|S td|}|jS )z÷Retrieve the CollectionAdapter associated with the given state.
|
|
if user_data is None, retrieves it from the state using normal
|
"get()" rules, which will fire lazy callables or return the "empty"
|
collection value.
|
|
Nr= rQ )rí r" r1 r r )r r¾ rî rj r Zfetch_user_datarw rw r rl s
|
|
)NFNN)..)..)#rÈ rÐ rÑ rÒ r r r
|
rë r rÔ rÓ r r r2 r r0 r. r r r rL rä r3 r r@ rB r r5 rá rf r r7 r rl rð rw rw rß r rr B sn
|
÷+üü- ú ú ú÷ Q û û ûûrr zQueryableAttribute[Any]r rÜ )r rf Úuselistr c s j jj fdd fdd} fdd}fdd}rhtjd |d
|
d
|
d
|
d ntjd |d
|
d
|
d
|
d tjd |d
|
d
|
d
|
d dS )z6Apply listeners to synchronize a two-way relationship.c s$ t dt| |j|j jjf d S )NzBidirectional attribute conflict detected: Passing object %s to attribute "%s" triggers a modify event on attribute "%s" via the backref "%s".)r` r9 r rg )Ú child_stater; Ú
|
child_impl)r rw r Ú_acceptable_key_err; s üüÿz.backref_listeners.<locals>._acceptable_key_errc s ||kr |S |d k r~|t k r~|tk r~t|t| }}|j j}|jsV|jsV|j}n|j }||k r~|j
|
||| ¡ j t d |d k r t|t| } }
|
| j j} |jk rÈ|j| jk rÈ | || | j } t| rÜ| jnd } || k r || k r | j| |
|
| ¡ |t d |S r< )r1 r* r r r rg r r r r r r' r r. r rq rs r@ )r¾ ÚchildZoldchildr; r± Ú old_stateZold_dictrg Zcheck_recursive_tokenr² Ú
|
child_dictr³ Úcheck_append_tokenÚcheck_bulk_replace_token)r´ rf Ú parent_implr rw r Ú"emit_backref_from_scalar_set_eventI sd ÿþýþ û
|
þ ÿ
|
þ ÿýÿþûz=backref_listeners.<locals>.emit_backref_from_scalar_set_eventc s |d kr d S t |t| }}|j j}|jk rL|j|jk rL | || |j}t|r`|jnd }||k r||k r|j||| ¡ |t
|
d |S r< ) r r r rg r r rq rs r@ r' r. ) r¾ rµ r; r± r² r· r³ r¸ r¹ )r´ rf r rw r Ú)emit_backref_from_collection_append_event s4 ÿ
|
þ ÿýÿþûzDbackref_listeners.<locals>.emit_backref_from_collection_append_eventc
|
s¼ |d k r¸|t k r¸|tk r¸t|t| }}|j j}|js\|js\|j}|j }oXj } n |j}t
|
|rp|j nd }d} ||k r¸||k r¸| r t | jj |¡s¸|j||| ¡ |td d S )NFr= )r1 r* r r r rg r r r r rq rs r= Z has_dupesr rf r r' r. )
|
r¾ rµ r; r± r² r· r³ Zcheck_remove_tokenZcheck_replace_tokenZcheck_for_dupes_on_remove)rf rº r± rw r Ú)emit_backref_from_collection_remove_event° sF ÿþýþ ÿýÿþ
|
üûzDbackref_listeners.<locals>.emit_backref_from_collection_remove_eventr@ T)rÿ ÚrawZ include_keyrá rB N)rg r r; Úlisten)r rf r± r» r¼ r½ rw )r´ r rf rº r r± r Úbackref_listeners+ s> C$1ú ú úrÀ Z
|
NO_HISTORYc @ sÚ e Zd ZU dZded< ded< ded< dddd Zddd
|
d Zd dd dZd dddZd dddZ ddddZ
|
d dddZ e dddd ddd Z e efd dddd d d d Ze d!ddd dd"d#Zd$S )%r a A 3-tuple of added, unchanged and deleted values,
|
representing the changes which have occurred on an instrumented
|
attribute.
|
|
The easiest way to get a :class:`.History` object for a particular
|
attribute on an object is to use the :func:`_sa.inspect` function::
|
|
from sqlalchemy import inspect
|
|
hist = inspect(myobject).attrs.myattribute.history
|
|
Each tuple member is an iterable sequence:
|
|
* ``added`` - the collection of items added to the attribute (the first
|
tuple element).
|
|
* ``unchanged`` - the collection of items that have not changed on the
|
attribute (the second tuple element).
|
|
* ``deleted`` - the collection of items that have been removed from the
|
attribute (the third tuple element).
|
|
zUnion[Tuple[()], List[Any]]r¯ Ú unchangedÚdeletedr r
c C s | t kS r )rR r rw rw r Ú__bool__ s zHistory.__bool__c C s t | jp| jp| j S )zhReturn True if this :class:`.History` has no changes
|
and no existing, unchanged state.
|
|
)r r¯ r rÁ r rw rw r Úempty" s z History.emptyz Sequence[Any]c C s | j pg | jpg | jpg S )z3Return a collection of added + unchanged + deleted.)r¯ rÁ r r rw rw r Úsum* s ÿz History.sumc C s | j pg | jpg S )z)Return a collection of added + unchanged.)r¯ rÁ r rw rw r Ú non_deleted1 s zHistory.non_deletedc C s | j pg | jpg S )z+Return a collection of unchanged + deleted.)rÁ r r rw rw r Ú non_added6 s zHistory.non_addedc C s t | jp | jS )z2Return True if this :class:`.History` has changes.)r r¯ r r rw rw r Ú has_changes; s zHistory.has_changesc C s0 t dd | jD dd | jD dd | jD S )Nc S s g | ]}|d k rt |pd qS r r r rw rw r r B s ÿz$History.as_state.<locals>.<listcomp>c S s g | ]}|d k rt |pd qS r r r rw rw r r F s ÿc S s g | ]}|d k rt |pd qS r r r rw rw r r J s ÿ)r r¯ rÁ r r rw rw r Úas_state@ s þþþ÷zHistory.as_staterG rc r )r r¾ rT r c C s° |j |jt¡}|tkr<|tkr,| dddS | d|gdS np|tk rb| ||¡dkrb| d|gdS t|tkrd}t|tkrd }n|g}|tkr| dd|S | |gd|S d S )Nrw T)r4 rí rf r_ r* r r$ Ú_NO_STATE_SYMBOLS©rÞ r r¾ rT r] r rw rw r rQ P s$ ÿþ z History.from_scalar_attributer\ )r r¾ rT r] r c C s¸ |t kr|j |jt ¡}|t krD|tkr4| dddS | d|gdS np||krb|tk rb| d|gdS t|tksv|d krd}t|tkrd }n|g}|tkr¦| dd|S | |gd|S d S )Nrw )r_ r4 rí rf r* r$ rÊ rË rw rw r r^ y s
|
z History.from_object_attributerr c sÄ |j |jt¡}|tkr$| dddS t|d}|tkrF| t|ddS |tkr^| dt|dS dd |D }dd |D }t| t|| fdd|D fdd|D fdd|D S d S ) Nrw r c S s$ g | ] }|d k rt |pd |fqS r r r rw rw r r ² s ÿz+History.from_collection.<locals>.<listcomp>c S s$ g | ] }|d k rt |pd |fqS r r r rw rw r r ¶ s ÿc s g | ]\}}| kr|qS rw rw r r rw r r ¿ s c s g | ]\}}| kr|qS rw rw r r rw r r À s c s g | ]\}}| kr|qS rw rw r r rw r r Á s )r4 rí rf r_ r* rÆ r¦ r )rÞ r r¾ rT r] r r rw r r r s*
|
þþýzHistory.from_collectionN)rÈ rÐ rÑ rÒ rÔ rà rÄ rÅ rÆ rÇ rÈ rÉ Ú classmethodrQ r_ r^ r rw rw rw r r s$
|
(û&r rw rà r5 )r' rf r r c C s t t| ||S )a
|
Return a :class:`.History` record for the given object
|
and attribute key.
|
|
This is the **pre-flush** history for a given attribute, which is
|
reset each time the :class:`.Session` flushes changes to the
|
current database transaction.
|
|
.. note::
|
|
Prefer to use the :attr:`.AttributeState.history` and
|
:meth:`.AttributeState.load_history` accessors to retrieve the
|
:class:`.History` for instance attributes.
|
|
|
:param obj: an object whose class is instrumented by the
|
attributes package.
|
|
:param key: string attribute name.
|
|
:param passive: indicates loading behavior for the attribute
|
if the value is not already present. This is a
|
bitflag attribute, which defaults to the symbol
|
:attr:`.PASSIVE_OFF` indicating all necessary SQL
|
should be emitted.
|
|
.. seealso::
|
|
:attr:`.AttributeState.history`
|
|
:meth:`.AttributeState.load_history` - retrieve history
|
using loader callables if the value is not locally present.
|
|
)Úget_state_historyr )r' rf r rw rw r r È s %r r8 c C s | ||¡S r )r )r¾ rf r rw rw r rÍ ð s rÍ FrP )rÞ r' rf r¿ r c C s t | }t|}| |||¡S )ZTODO)r# r Ú
|
has_parent)rÞ r' rf r¿ r r¾ rw rw r rÎ ö s rÎ )rú ru rv ræ )re rf rh rs rú r± r c K s$ t | ||||d}t| |f| |S )N)rh rs rú )Úregister_descriptorÚregister_attribute_impl)re rf rh rs rú r± Údescrw rw r Úregister_attributeÿ s ÿrÒ zOptional[_LoaderCallable]z Optional[Type[AttributeImpl]]) re rf r± r Ú useobjectÚ
|
impl_classÚbackrefr± r c K sÞ t | }|r*| dd ¡} | || p$t¡}
|
n | dd ¡}
|
td|| j} |rdtd|| ||
|
| f|} nJ|rt| ||| fd|
|
i|} n*|rt| ||| f|} nt| ||| f|} | || _ |rÌt
|
|| || | |¡ || S )Nr r z Type[WriteOnlyAttributeImpl]) r# r Zinstrument_collection_classr¦ r ro rr r\ rG rg rÀ Zpost_configure_attribute) re rf r± r rÓ rÔ rÕ r± r Úfactoryr ro rg rw rw r rÐ
|
s^ ÿ ÿ ÿÿ ÿÿÿ ÿÿ
|
|
rÐ z Type[Any]rr )re rf rh rs rú r c C s. t | }t| |||d}||_| ||¡ |S )N)rh rs )r# rÚ rÒ Zinstrument_attribute)re rf rh rs rú r rö rw rw r rÏ C
|
s ÿ rÏ )re rf r c C s t | |¡ d S r )r# Zuninstrument_attribute)re rf rw rw r Úunregister_attributeW
|
s r× rR )r' rf r c C s t | }|j}t|||S )a4 Initialize a collection attribute and return the collection adapter.
|
|
This function is used to provide direct access to collection internals
|
for a previously unloaded attribute. e.g.::
|
|
collection_adapter = init_collection(someobject, 'elements')
|
for elem in values:
|
collection_adapter.append_without_event(elem)
|
|
For an easier way to do the above, see
|
:func:`~sqlalchemy.orm.attributes.set_committed_value`.
|
|
:param obj: a mapped object
|
|
:param key: string attribute name where the collection is located.
|
|
)r r Úinit_state_collection)r' rf r¾ rî rw rw r rx [
|
s rx rM )r¾ rî rf r c C st | j | j}tr t|ts t| |d¡}|dk rH|j}| | ||d¡ | | |¡}|j
|
| ||t j d}| ¡ |S )zInitialize a collection attribute and return the collection adapter.
|
|
Discards any existing collection which may be there.
|
|
NFr= )r rg r r ra r~ r r rf r3 rl r5 r. Z _reset_empty)r¾ rî rf ÚattrrO r¬ rj rc rw rw r rØ r
|
s ÿrØ c C s, t | t| }}|j| j |||¡ dS )a[ Set the value of an attribute with no history events.
|
|
Cancels any previous history present. The value should be
|
a scalar value for scalar-holding attributes, or
|
an iterable for any collection-holding attribute.
|
|
This is the same underlying method used when a lazy loader
|
fires off and loads additional data from the database.
|
In particular, this method can be used by application code
|
which has loaded additional attributes or collections through
|
separate queries, which can then be attached to an instance
|
as though it were part of its original loaded state.
|
|
N)r r r rg r7 )r rf r¡ r¾ rî rw rw r r7
|
s r7 r )r rf r¡ r; r c C s. t | t| }}|j| j ||||¡ dS )as Set the value of an attribute, firing history events.
|
|
This function may be used regardless of instrumentation
|
applied directly to the class, i.e. no descriptors are required.
|
Custom attribute management schemes will need to make usage
|
of this method to establish attribute state as understood
|
by SQLAlchemy.
|
|
:param instance: the object that will be modified
|
|
:param key: string name of the attribute
|
|
:param value: value to assign
|
|
:param initiator: an instance of :class:`.Event` that would have
|
been propagated from a previous event listener. This argument
|
is used when the :func:`.set_attribute` function is being used within
|
an existing event listening function where an :class:`.Event` object
|
is being supplied; the object may be used to track the origin of the
|
chain of events.
|
|
.. versionadded:: 1.2.3
|
|
N)r r r rg rá )r rf r¡ r; r¾ rî rw rw r Ú set_attribute
|
s rÚ )r rf r c C s& t | t| }}|j| j ||¡S )aZ Get the value of an attribute, firing any callables required.
|
|
This function may be used regardless of instrumentation
|
applied directly to the class, i.e. no descriptors are required.
|
Custom attribute management schemes will need to make usage
|
of this method to make usage of attribute state as understood
|
by SQLAlchemy.
|
|
)r r r rg rí ©r rf r¾ rî rw rw r Ú get_attributeÂ
|
s
|
rÜ c C s* t | t| }}|j| j ||¡ dS )aQ Delete the value of an attribute, firing history events.
|
|
This function may be used regardless of instrumentation
|
applied directly to the class, i.e. no descriptors are required.
|
Custom attribute management schemes will need to make usage
|
of this method to establish attribute state as understood
|
by SQLAlchemy.
|
|
N)r r r rg rä rÛ rw rw r Ú del_attributeÐ
|
s
|
rÝ c C sD t | t| }}|j| j}|j ||j¡ |j||tdd dS )aø Mark an attribute on an instance as 'modified'.
|
|
This sets the 'modified' flag on the instance and
|
establishes an unconditional change event for the given attribute.
|
The attribute must have a value present, else an
|
:class:`.InvalidRequestError` is raised.
|
|
To mark an object "dirty" without referring to any specific attribute
|
so that it is considered within a flush, use the
|
:func:`.attributes.flag_dirty` call.
|
|
.. seealso::
|
|
:func:`.attributes.flag_dirty`
|
|
T©Z is_userlandN) r r r rg ro Úmodifiedr rM r* )r rf r¾ rî rg rw rw r Ú flag_modifiedÞ
|
s rà rã c C s( t | t| }}|j|dtdd dS )a¹ Mark an instance as 'dirty' without any specific attribute mentioned.
|
|
This is a special operation that will allow the object to travel through
|
the flush process for interception by events such as
|
:meth:`.SessionEvents.before_flush`. Note that no SQL will be emitted in
|
the flush process for an object that has no changes, even if marked dirty
|
via this method. However, a :meth:`.SessionEvents.before_flush` handler
|
will be able to see the object in the :attr:`.Session.dirty` collection and
|
may establish changes on it, which will then be included in the SQL
|
emitted.
|
|
.. versionadded:: 1.2
|
|
.. seealso::
|
|
:func:`.attributes.flag_modified`
|
|
NTrÞ )r r rM r* )r r¾ rî rw rw r Ú
|
flag_dirtyõ
|
s rá )F)FNFNN)N)«rÒ Ú
|
__future__r Z dataclassesr Útypingr r r r r r r r
|
r r r r r r r Ú r r rì r Ú_typingr r@ r r r r r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r; r< r= r> r? ZsqlZsql_baserA rB rC rD Z sql.cache_keyrE Z sql.visitorsrF rG Z util.typingrH rI rJ rK rL rM rN rO rP rQ rR rS Z relationshipsrT r¾ rU rV Z writeonlyrW Z
|
event.baserX Z sql._typingrY rZ r[ r\ Zsql.annotationr] Z sql.elementsr^ r_ Z sql.operatorsr` Zsql.selectablera rb rà r- r Z_self_inspectsZInspectionAttrZPropComparatorZJoinTargetRoleZ OnClauseRoleZ ImmutableZSlotsMemoizedHasCacheKeyrÄ rd r rÚ Z dataclassrò r ÚsymbolrI r rH r r r ZAttributeEventÚEventrt rG r\ ra rq Ú
|
attrgetterrr rÀ r_ Ú frozensetr$ rÊ r rR r rÍ rÎ rÒ rÐ rÏ r× rx rØ r7 rÚ rÜ rÝ rà rá rw rw rw r Ú<module> sf ÿ
|
ö g?
|
+
|
|
|
|
|
3 g VH
|
l T
|
D ÿ)ÿ ÿú ù :ú ü"
|
