?????????? ????????? - ??????????????? - /home/agenciai/.local/lib/python3.9/site-packages/sqlalchemy/orm/__pycache__/state.cpython-39.pyc
???????
a ��Jh&� � @ s� U d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z dd lm Z dd lm Z dd lm Z dd lm Z dd lZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm Z dd lm Z dd l m!Z! d dlmZ" d d lm#Z# d d lm$Z$ d d!l%m&Z& d d"l%m'Z' e �r<dd#lm(Z( dd$lm)Z) dd%lm*Z* dd&l+m,Z, dd'l+m-Z- dd(lm.Z. dd)l/m0Z0 dd*l1m2Z2 dd+l3m4Z4 dd,lm5Z5 dd-l6m7Z7 dd.l8m9Z9 d d/l:m;Z; d d0l<m=Z> d d1l<m?Z? e �rLd2e@d3< nd ZAe �sZd Z>G d4d5� d5e'�ZBG d6d7� d7e'e �ZCe#jDG d8d9� d9ejEee ��ZFG d:d;� d;�ZGG d<d=� d=�ZHd S )>z�Defines instrumentation of instances. This module is usually not directly visible to user applications, but defines a large part of the ORM's interactivity. � )� annotations)�Any)�Callable)�Dict)�Generic)�Iterable)�Optional)�Set)�Tuple)� TYPE_CHECKING)�UnionN� )�base)�exc)� interfaces)�_O)�is_collection_impl)� ATTR_WAS_SET)�INIT_OK)�LoaderCallableStatus)� NEVER_SET)�NO_VALUE)�PASSIVE_NO_INITIALIZE)�PASSIVE_NO_RESULT)� PASSIVE_OFF)�SQL_OK)� PathRegistry� )� inspection)�util)�Literal)�Protocol)�_IdentityKeyType)� _InstanceDict)�_LoaderCallable)� AttributeImpl)�History)� PassiveFlag)�_AdaptedCollectionProtocol)� IdentityMap)� ClassManager)� ORMOption)�Mapper)�Session)�Row)� async_session)� AsyncSessionz)weakref.WeakValueDictionary[int, Session]� _sessionsc @ s e Zd Zdd�dd�ZdS )�_InstanceDictProto�Optional[IdentityMap]��returnc C s d S �N� ��selfr7 r7 �I/home/agenciai/.local/lib/python3.9/site-packages/sqlalchemy/orm/state.py�__call__Q � z_InstanceDictProto.__call__N)�__name__� __module__� __qualname__r; r7 r7 r7 r: r2 P s r2 c @ s$ e Zd ZdZddddd�dd�Zd S ) �_InstallLoaderCallableProtoa used at result loading time to install a _LoaderCallable callable upon a specific InstanceState, which will be used to populate an attribute when that attribute is accessed. Concrete examples are per-instance deferred column loaders and relationship lazy loaders. �InstanceState[_O]r# �Row[Any]�None��state�dict_�rowr5 c C s d S r6 r7 )r9 rE rF rG r7 r7 r: r; ^ s z$_InstallLoaderCallableProto.__call__N)r= r> r? �__doc__r; r7 r7 r7 r: r@ T s r@ c @ s| e Zd ZU dZdZded< dZded< dZded < dZded < d Z d ed < e j Z ded< dZ ded< dZded< ded< ded< dZded< dZded< dZded< dZded < dZded < d Zded < dZd ed!< dZd"ed#< d$ed%< es�d&d'� Zd(ed)< d*ed+< e�sejZd,dd-�d.d/�Z ej d0d1�d2d3��Z e dd1�d4d5��Z e dd1�d6d7��Z!e dd1�d8d9��Z"e dd1�d:d;��Z#e dd1�d<d=��Z$e dd1�d>d?��Z%ej&e�'d@�dd1�dAdB���Z(dCdDdE�dFdG�Z)e dHd1�dIdJ��Z*e dKd1�dLdM��Z+e dNd1�dOdP��Z,e dQd1�dRdS��Z-e dd1�dTdU��Z.ej dVd1�dWdX��Z/ej dYd1�dZd[��Z0ej d\d1�d]d^��Z1ej d_d1�d`da��Z2e dd1�dbdc��Z3e4d�dddeddDdf�dgdh��Z5d�dHdDdi�djdk�Z6dDd1�dldm�Z7ddDdn�dodp�Z8e dqd1�drds��Z9dtdtdDdu�dvdw�Z:dCdxdydz�d{d|�Z;dCd}dE�d~d�Z<dCd�dE�d�d��Z=dd1�d�d��Z>ddDd��d�d��Z?dqdCdDd��d�d��Z@d�dDd��d�d��ZAe4dd�dtd�d��d�d���ZBdqd�dDd��d�d��ZCd�dqd�ddDd��d�d��ZDd�dxd�d��d�d��ZEe d(d1�d�d���ZFd�d(d��d�d��ZGe d(d1�d�d���ZHe e�Id�d��d(d1�d�d����ZJe d(d1�d�d���ZKd�dqd�dtdddDd��d�d��ZLdqd�dDd��d�d��ZMd�dqd�dDd��d�d��ZNe4d�d�d�dDd��d�d���ZOdS )�� InstanceStatea Tracks state information at the instance level. The :class:`.InstanceState` is a key object used by the SQLAlchemy ORM in order to track the state of an object; it is created the moment an object is instantiated, typically as a result of :term:`instrumentation` which SQLAlchemy applies to the ``__init__()`` method of the class. :class:`.InstanceState` is also a semi-public object, available for runtime inspection as to the state of a mapped instance, including information such as its current status within a particular :class:`.Session` and details about data on individual attributes. The public API in order to acquire a :class:`.InstanceState` object is to use the :func:`_sa.inspect` system:: >>> from sqlalchemy import inspect >>> insp = inspect(some_mapped_object) >>> insp.attrs.nickname.history History(added=['new nickname'], unchanged=(), deleted=['nickname']) .. seealso:: :ref:`orm_mapper_inspection_instancestate` )�__dict__� __weakref__�class_�manager�obj�committed_state�expired_attributeszClassManager[_O]rM Nz Optional[int]� session_idz Optional[_IdentityKeyType[_O]]�key�runidr7 zTuple[ORMOption, ...]� load_optionsr � load_path� insert_orderzOptional[object]� _strong_objzweakref.ref[_O]rN zDict[str, Any]rO F�bool�modified�expired�_deleted� _load_pending� _orphaned_outside_of_sessionT� is_instance�object�identity_tokenzOptional[Dict[str, Any]]�_last_known_valuesr2 �_instance_dictc C s dS )z+default 'weak reference' for _instance_dictNr7 r8 r7 r7 r: rb � s z InstanceState._instance_dictzSet[str]rP z:Dict[str, Callable[[InstanceState[_O], PassiveFlag], Any]]� callablesr )rN rM c C s0 |j | _|| _t�|| j�| _i | _t� | _ d S r6 ) � __class__rL rM �weakref�ref�_cleanuprN rO �setrP )r9 rN rM r7 r7 r: �__init__� s zInstanceState.__init__z'util.ReadOnlyProperties[AttributeState]r4 c s t �� fdd�� jD ��S )aa Return a namespace representing each attribute on the mapped object, including its current value and history. The returned object is an instance of :class:`.AttributeState`. This object allows inspection of the current data within an attribute as well as attribute history since the last flush. c s i | ]}|t � |��qS r7 )�AttributeState)�.0rR r8 r7 r: � <dictcomp>� r< z'InstanceState.attrs.<locals>.<dictcomp>)r ZReadOnlyPropertiesrM r8 r7 r8 r: �attrs� s �zInstanceState.attrsc C s | j du o| j S )z}Return ``True`` if the object is :term:`transient`. .. seealso:: :ref:`session_object_states` N�rR � _attachedr8 r7 r7 r: � transient� s zInstanceState.transientc C s | j du o| jS )z{Return ``True`` if the object is :term:`pending`. .. seealso:: :ref:`session_object_states` Nrn r8 r7 r7 r: �pending� s zInstanceState.pendingc C s | j duo| jo| jS )a� Return ``True`` if the object is :term:`deleted`. An object that is in the deleted state is guaranteed to not be within the :attr:`.Session.identity_map` of its parent :class:`.Session`; however if the session's transaction is rolled back, the object will be restored to the persistent state and the identity map. .. note:: The :attr:`.InstanceState.deleted` attribute refers to a specific state of the object that occurs between the "persistent" and "detached" states; once the object is :term:`detached`, the :attr:`.InstanceState.deleted` attribute **no longer returns True**; in order to detect that a state was deleted, regardless of whether or not the object is associated with a :class:`.Session`, use the :attr:`.InstanceState.was_deleted` accessor. .. versionadded: 1.1 .. seealso:: :ref:`session_object_states` N�rR ro r[ r8 r7 r7 r: �deleted� s zInstanceState.deletedc C s | j S )aN Return True if this object is or was previously in the "deleted" state and has not been reverted to persistent. This flag returns True once the object was deleted in flush. When the object is expunged from the session either explicitly or via transaction commit and enters the "detached" state, this flag will continue to report True. .. seealso:: :attr:`.InstanceState.deleted` - refers to the "deleted" state :func:`.orm.util.was_deleted` - standalone function :ref:`session_object_states` )r[ r8 r7 r7 r: � was_deleted s zInstanceState.was_deletedc C s | j duo| jo| j S )a Return ``True`` if the object is :term:`persistent`. An object that is in the persistent state is guaranteed to be within the :attr:`.Session.identity_map` of its parent :class:`.Session`. .. seealso:: :ref:`session_object_states` Nrr r8 r7 r7 r: � persistent) s zInstanceState.persistentc C s | j duo| j S )z|Return ``True`` if the object is :term:`detached`. .. seealso:: :ref:`session_object_states` Nrn r8 r7 r7 r: �detached8 s zInstanceState.detachedzsqlalchemy.orm.sessionc C s | j d uo| j tjjjv S r6 )rQ r Z preloadedZ orm_sessionr1 r8 r7 r7 r: ro C s �zInstanceState._attached�strrC )rR r5 c C s, | j }|du ri | _ }||vr(t||< dS )z|Track the last known value of a particular key after expiration operations. .. versionadded:: 1.3 N)ra r )r9 rR �lkvr7 r7 r: �_track_last_known_valueK s z%InstanceState._track_last_known_valuezOptional[Session]c C s* | j r&z t| j W S ty$ Y n0 dS )aL Return the owning :class:`.Session` for this instance, or ``None`` if none available. Note that the result here can in some cases be *different* from that of ``obj in session``; an object that's been deleted will report as not ``in session``, however if the transaction is still in progress, this attribute will still refer to that session. Only when the transaction is completed does the object become fully detached under normal circumstances. .. seealso:: :attr:`_orm.InstanceState.async_session` N)rQ r1 �KeyErrorr8 r7 r7 r: �sessionY s zInstanceState.sessionzOptional[AsyncSession]c C s* t du r dS | j}|dur"t |�S dS dS )aG Return the owning :class:`_asyncio.AsyncSession` for this instance, or ``None`` if none available. This attribute is only non-None when the :mod:`sqlalchemy.ext.asyncio` API is in use for this ORM object. The returned :class:`_asyncio.AsyncSession` object will be a proxy for the :class:`_orm.Session` object that would be returned from the :attr:`_orm.InstanceState.session` attribute for this :class:`_orm.InstanceState`. .. versionadded:: 1.4.18 .. seealso:: :ref:`asyncio_toplevel` N)�_async_providerr{ )r9 �sessr7 r7 r: r/ q s zInstanceState.async_sessionz Optional[_O]c C s | � � S )z�Return the mapped object represented by this :class:`.InstanceState`. Returns None if the object has been garbage collected )rN r8 r7 r7 r: r_ � s zInstanceState.objectzOptional[Tuple[Any, ...]]c C s | j du rdS | j d S dS )a� Return the mapped identity of the mapped object. This is the primary key identity as persisted by the ORM which can always be passed directly to :meth:`_query.Query.get`. Returns ``None`` if the object has no primary key identity. .. note:: An object which is :term:`transient` or :term:`pending` does **not** have a mapped identity until it is flushed, even if its attributes include primary key values. Nr �rR r8 r7 r7 r: �identity� s zInstanceState.identityc C s | j S )z�Return the identity key for the mapped object. This is the key used to locate the object within the :attr:`.Session.identity_map` mapping. It contains the identity as returned by :attr:`.identity` within it. r~ r8 r7 r7 r: � identity_key� s zInstanceState.identity_keyz4Dict[int, Union[Literal[False], InstanceState[Any]]]c C s i S r6 r7 r8 r7 r7 r: �parents� s zInstanceState.parentsz Dict[str, PendingCollection]c C s i S r6 r7 r8 r7 r7 r: �_pending_mutations� s z InstanceState._pending_mutationsz%Dict[str, _AdaptedCollectionProtocol]c C s i S r6 r7 r8 r7 r7 r: �_empty_collections� s z InstanceState._empty_collectionsz Mapper[_O]c C s | j jS )z<Return the :class:`_orm.Mapper` used for this mapped object.)rM �mapperr8 r7 r7 r: r� � s zInstanceState.mapperc C s t | j�S )z�Return ``True`` if this object has an identity key. This should always have the same value as the expression ``state.persistent`` or ``state.detached``. )rX rR r8 r7 r7 r: � has_identity� s zInstanceState.has_identityzIterable[InstanceState[_O]]r- )�statesr{ � to_transientr5 c C s� |j jp d }|j jpd }|j jp"d }|j jp.d }|D ]�}|j} |jd u } | oR| } d |_|rh|jrh|`| r�|r�|d ur�|||� q�|d ur�|||� n.| r�|d ur�|||� n| r�|d ur�|||� d |_q4d S r6 ) �dispatch�persistent_to_detached�deleted_to_detached�pending_to_transient�persistent_to_transientr[ rR rQ rW ) r9 r� r{ r� r� r� r� r� rE rs rq ru r7 r7 r: �_detach_states� s0 � � z InstanceState._detach_states)r{ r5 c C s$ |rt �| g|� n d | _| _d S r6 )rI r� rQ rW )r9 r{ r7 r7 r: �_detach� s zInstanceState._detachc C s | � � d S r6 )r� r8 r7 r7 r: �_dispose� s zInstanceState._dispose)rf r5 c C s: t du r dS | �� }|dur*|�| � | `d | _| _dS )z�Weakref callback cleanup. This callable cleans out the state when it is being garbage collected. this _cleanup **assumes** that there are no strong refs to us! Will not work otherwise! N)�dictrb Z _fast_discardrQ rW )r9 rf � instance_dictr7 r7 r: rg s zInstanceState._cleanupr# c C s" | � � }|durt�|�S i S dS )a Return the instance dict used by the object. Under normal circumstances, this is always synonymous with the ``__dict__`` attribute of the mapped object, unless an alternative instrumentation system has been configured. In the case that the actual object has been garbage collected, this accessor returns a blank dictionary. N)rN r r� )r9 �or7 r7 r: r� s zInstanceState.dictr )�mixed�kwargsr5 c O s� | d | d | dd � }}}|j }|j�|||� z |j| dd � i |�� W nD t�� � |j�|||� W d � n1 s�0 Y Y n0 d S )Nr r r )rM r� �initZ original_initr Z safe_reraiseZ init_failure)r� r� r9 �instance�argsrM r7 r7 r: �_initialize_instance2 s z"InstanceState._initialize_instancer' r& )rR �passiver5 c C s | j | j�| | j|�S r6 )rM �impl� get_historyr� )r9 rR r� r7 r7 r: r� > s zInstanceState.get_historyr% c C s | j | jS r6 )rM r� �r9 rR r7 r7 r: �get_implA s zInstanceState.get_impl�PendingCollectionc C s || j vrt� | j |< | j | S r6 )r� r� r� r7 r7 r: �_get_pending_mutationD s z#InstanceState._get_pending_mutationc sZ � � � � j� j� jd�}|�� fdd�dD �� � jrD� j�� |d< � j�� |�|d< |S )N)r� rL rO rP c 3 s& | ] }|� j v r|� j | fV qd S r6 )rJ �rk �kr8 r7 r: � <genexpr>P s �z-InstanceState.__getstate__.<locals>.<genexpr>) r� rY rZ rc rR r� rT rL rP �inforU rM ) rN rL rO rP �updaterU � serializerM � _serialize)r9 � state_dictr7 r8 r: � __getstate__I s ��zInstanceState.__getstate__)r� r5 c s2 � d }|d ur*t �|| j�| _|j| _ndd� | _� d | _� �di �| _� �di �| _� �di �| _ � �dd �| _ � �d d �| _ d � v r�| j � � d � d � v r�� d | _� d | _n d � v rΈ d | _nt� | _| j� � fdd�dD �� | j�r| jd | _d� v �r t�� d �| _� d | |� � d S )Nr� c S s d S r6 r7 r7 r7 r7 r: �<lambda>m r< z,InstanceState.__setstate__.<locals>.<lambda>rL rO r� r� rY FrZ r� rc rP c s g | ]}|� v r|� | f�qS r7 r7 r� �r� r7 r: � <listcomp>� s �z.InstanceState.__setstate__.<locals>.<listcomp>)rR rT r rU rM )re rf rg rN rd rL �getrO r� r� rY rZ r� r� rc rP rh rJ rR r` r Z deserializerU )r9 r� �instr7 r� r: � __setstate__g s: �� zInstanceState.__setstate__)rF rR r5 c C sV |� |d�}| j| j}|dur2t|�r2|�|� | j�|� | jrR| j� |d� dS )zHRemove the given attribute and any callables associated with it.N)�poprM r� r �_invalidate_collectionrP �discardrc )r9 rF rR �oldZ manager_implr7 r7 r: �_reset� s zInstanceState._reset�InstanceState[Any])�from_r5 c C s d|j v rt|j�| _d S �Nrc )rJ r� rc )r9 r� r7 r7 r: �_copy_callables� s z InstanceState._copy_callablesr$ z _InstallLoaderCallableProto[_O])rM �fnrR r5 c sR |� j }t|�r4|� ddddd�� ��fdd� }nddddd���fdd� }|S ) NrA r# rB rC rD c s< d| j vri | _|��d �}|d ur.� �|� �| j�< d S r� )rJ rc r� r� )rE rF rG r� �Z fixed_implr� rR r7 r: � _set_callable� s zGInstanceState._instance_level_callable_processor.<locals>._set_callablec s d| j vri | _� | j�< d S r� )rJ rc )rE rF rG )r� rR r7 r: r� � s )r� r )�clsrM r� rR r� r� r7 r� r: �"_instance_level_callable_processor� s z0InstanceState._instance_level_callable_processorzSet[InstanceState[Any]])rF � modified_setr5 c s d| _ | jr&|�| � | j�� d| _d | _d| jv r>| jd= d| jv rP| jd= | j�dd� | j j D �� | j r�| j� | j �D ] }| j |= q~| j j � � �D ]}� �|�}d|j_q�| jr�| j�� fdd�| jD �� | j j� � �D ] }� |= q�| j j�| d � d S ) NTFr� r� c S s g | ] }|j �qS r7 r~ )rk r� r7 r7 r: r� � r< z)InstanceState._expire.<locals>.<listcomp>c s i | ]}|� v r|� | �qS r7 r7 r� �rF r7 r: rl � r< z)InstanceState._expire.<locals>.<dictcomp>)rZ rY r� rO �clearrW rJ rP r� rM Z _loader_implsrc � intersectionZ_collection_impl_keysr� Z _sa_adapterZ invalidatedra Z _all_key_setr� �expire)r9 rF r� r� � collectionrR r7 r� r: �_expire� s4 � �zInstanceState._expirez Iterable[str])rF �attribute_names� no_loaderr5 c C s� | j �dd �}| j}|D ]�}| j| j}|jr`|rB|js||v rBq| j�|� |r`||v r`||= |� |t �}t |�r�|t ur�|� |� | j } | d ur�|| v r�|t ur�|| |< | j� |d � |r|� |d � q| jj�| |� d S )Nr� )rJ r� rc rM r� �accepts_scalar_loaderZ callable_rP �addr� r r r� ra rO r� r� ) r9 rF r� r� rq rc rR r� r� rx r7 r7 r: �_expire_attributes� s( z InstanceState._expire_attributesrA r )rE r� r5 c sP |t @ s tS � j�� j�}|�� fdd�|D ��}� j�� ||� � j�� t S )z�__call__ allows the InstanceState to act as a deferred callable for loading expired attributes, which is also serializable (picklable). c 3 s | ]}� j | jjs|V qd S r6 )rM r� Zload_on_unexpire�rk �attrr8 r7 r: r� s �z.InstanceState._load_expired.<locals>.<genexpr>) r r rP r� � unmodified� differencerM Zexpired_attribute_loaderr� r )r9 rE r� Ztoloadr7 r8 r: � _load_expired s � zInstanceState._load_expiredc C s t | j��| j�S )z8Return the set of keys which have no uncommitted changes)rh rM r� rO r8 r7 r7 r: r� - s zInstanceState.unmodified)�keysr5 c C s t |��| j��| j�S )z*Return self.unmodified.intersection(keys).)rh r� rM r� rO )r9 r� r7 r7 r: �unmodified_intersection3 s ���z%InstanceState.unmodified_intersectionc C s t | j��| j��| j�S )z�Return the set of keys which do not have a loaded value. This includes expired attributes and any other attribute that was never populated or modified. )rh rM r� rO r� r8 r7 r7 r: �unloaded< s ���zInstanceState.unloadedz2.0zsThe :attr:`.InstanceState.unloaded_expirable` attribute is deprecated. Please use :attr:`.InstanceState.unloaded`.c C s | j S )z�Synonymous with :attr:`.InstanceState.unloaded`. This attribute was added as an implementation-specific detail at some point and should be considered to be private. )r� r8 r7 r7 r: �unloaded_expirableJ s z InstanceState.unloaded_expirablec s � j �� fdd�� jD ��S )Nc 3 s | ]}� j | jjr|V qd S r6 )rM r� r� r� r8 r7 r: r� [ s �z5InstanceState._unloaded_non_object.<locals>.<genexpr>)r� r� rM r8 r7 r8 r: �_unloaded_non_objectY s �z"InstanceState._unloaded_non_objectzOptional[AttributeImpl])rF r� �previousr� � is_userlandr5 c C s� |r�|j sd S |r,|j|vr,t�d|j ��|j| jvs<|r�|r�trPt|�sPJ �|tu rl|j|v rl||j }|d ttfvr�|� |�}|| j|j< | j }|d ur�|j|v r�t||j< | j r�| j d u s�| j �s|d| _ | �� }|r�t|j�}|j�| � nd}| �� } | j �rL| | _ |�sLzt| j } W n t�y6 Y n0 | jd u �rL| �� | d u �r||�r|t�d| j|j t�| �f ��d S )NzHCan't flag attribute '%s' modified; it's not present in the object stateTFzaCan't emit change event for attribute '%s' - parent object of type %s has been garbage collected.) Zsend_modified_eventsrR �sa_excZInvalidRequestErrorrO r r r r �copyra rQ rW rY rb rX � _modifiedr� rN r1 rz Z _transactionZ _autobegin_t�orm_excZObjectDereferencedErrorrM r Zstate_class_str) r9 rF r� r� r� r� rx r� Z has_modifiedr� r{ r7 r7 r: �_modified_eventa sZ �� ��z InstanceState._modified_event)rF r� r5 c C sb |D ]}| j �|d� qd| _| j�t|��|�� | jr^t| j��|��|�D ] }| j|= qPdS )a8 Commit attributes. This is used by a partial-attribute load operation to mark committed those attributes which were refreshed from the database. Attributes marked as "expired" can potentially remain "expired" after this step if a value was not populated in state.dict. NF)rO r� rZ rP �difference_updaterh r� rc )r9 rF r� rR r7 r7 r: �_commit� s ��zInstanceState._commitr3 )rF r� r5 c C s | � | |fg|� dS )aS commit all attributes unconditionally. This is used after a flush() or a full load/refresh to remove all pending state from the instance. - all attributes are marked as "committed" - the "strong dirty reference" is removed - the "modified" flag is set to False - any "expired" markers for scalar attributes loaded are removed. - lazy load callables for objects / collections *stay* Attributes marked as "expired" can potentially remain "expired" after this step if a value was not populated in state.dict. N)�_commit_all_states)r9 rF r� r7 r7 r: � _commit_all� s zInstanceState._commit_allz2Iterable[Tuple[InstanceState[Any], _InstanceDict]])�iter_r� r5 c C sd |D ]Z\}}|j }|j�� d|v r*|d= |j�|� |rL|jrL|j�|� d |_|_d|_ qdS )z.Mass / highly inlined version of commit_all().r� FN) rJ rO r� rP r� rY r� r� rZ rW )r9 r� r� rE rF r� r7 r7 r: r� � s z InstanceState._commit_all_states)F)N)F)FF)N)N)Pr= r> r? rH � __slots__�__annotations__rQ rR rS rT r �rootrU rV rW rY rZ r[ r\ r] r^ r` ra r rb r � EMPTY_DICTrc ri Zmemoized_propertyrm �propertyrp rq rs rt ru rv Znon_memoized_propertyZpreload_modulero ry r{ r/ r_ r r� r� r� r� r� r� � classmethodr� r� r� rg r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� � deprecatedr� r� r� r� r� r� r7 r7 r7 r: rI c s� �% ) 6 �! � �H � �rI c @ sz e Zd ZU dZdZded< ded< ddd�dd�Zed d �d d ��Zed d �d d��Z edd �dd��Z dd �dd�Z dS )rj a� Provide an inspection interface corresponding to a particular attribute on a particular mapped object. The :class:`.AttributeState` object is accessed via the :attr:`.InstanceState.attrs` collection of a particular :class:`.InstanceState`:: from sqlalchemy import inspect insp = inspect(some_mapped_object) attr_state = insp.attrs.some_attribute �rE rR r� rE rw rR c C s || _ || _d S r6 r� )r9 rE rR r7 r7 r: ri s zAttributeState.__init__r r4 c C s | j j�| jt�S )z�The current value of this attribute as loaded from the database. If the value has not been loaded, or is otherwise not present in the object's dictionary, returns NO_VALUE. )rE r� r� rR r r8 r7 r7 r: � loaded_value s zAttributeState.loaded_valuec C s | j j| j �| j �� | j j�S )z�Return the value of this attribute. This operation is equivalent to accessing the object's attribute directly or via ``getattr()``, and will fire off any pending loader callables if needed. )rE rM rR �__get__rN rL r8 r7 r7 r: �value s �zAttributeState.valuer& c C s | j �| jt�S )ai Return the current **pre-flush** change history for this attribute, via the :class:`.History` interface. This method will **not** emit loader callables if the value of the attribute is unloaded. .. note:: The attribute history system tracks changes on a **per flush basis**. Each time the :class:`.Session` is flushed, the history of each attribute is reset to empty. The :class:`.Session` by default autoflushes each time a :class:`_query.Query` is invoked. For options on how to control this, see :ref:`session_flushing`. .. seealso:: :meth:`.AttributeState.load_history` - retrieve history using loader callables if the value is not locally present. :func:`.attributes.get_history` - underlying function )rE r� rR r r8 r7 r7 r: �history" s zAttributeState.historyc C s | j �| jttA �S )a Return the current **pre-flush** change history for this attribute, via the :class:`.History` interface. This method **will** emit loader callables if the value of the attribute is unloaded. .. note:: The attribute history system tracks changes on a **per flush basis**. Each time the :class:`.Session` is flushed, the history of each attribute is reset to empty. The :class:`.Session` by default autoflushes each time a :class:`_query.Query` is invoked. For options on how to control this, see :ref:`session_flushing`. .. seealso:: :attr:`.AttributeState.history` :func:`.attributes.get_history` - underlying function )rE r� rR r r r8 r7 r7 r: � load_history> s zAttributeState.load_historyN) r= r> r? rH r� r� ri r� r� r� r� r� r7 r7 r7 r: rj � s rj c @ sd e Zd ZU dZdZded< ded< dd�d d �Zd d d �d d�Zddd�dd�Zddd�dd�Z dS )r� a A writable placeholder for an unloaded collection. Stores items appended to and removed from a collection that has not yet been loaded. When the collection is loaded, the changes stored in PendingCollection are applied to it to produce the final result. )� deleted_items� added_itemszutil.IdentitySetr� zutil.OrderedIdentitySetr� rC r4 c C s t �� | _t �� | _d S r6 )r Z IdentitySetr� ZOrderedIdentitySetr� r8 r7 r7 r: ri f s zPendingCollection.__init__r& )r� r5 c C s |� | j| j�S r6 )�_merger� r� )r9 r� r7 r7 r: �merge_with_historyj s z$PendingCollection.merge_with_historyr )r� r5 c C s( || j v r| j �|� n | j�|� d S r6 )r� �remover� r� �r9 r� r7 r7 r: �appendm s zPendingCollection.appendc C s( || j v r| j �|� n | j�|� d S r6 )r� r� r� r� r� r7 r7 r: r� s s zPendingCollection.removeN) r= r> r? rH r� r� ri r� r� r� r7 r7 r7 r: r� X s r� )IrH � __future__r �typingr r r r r r r r r r re � r r r� r Z_typingr r r r r r r r r r r Z path_registryr r� r r Z util.typingr r! r" r# r$ � attributesr% r& r' � collectionsr( r r) Zinstrumentationr* r+ r� r, r{ r- Zenginer. Zext.asyncio.sessionr/ r| r0 r� r1 r2 r@ Z_self_inspectsZInspectionAttrInforI rj r� r7 r7 r7 r: �<module> s� e
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0 |
proxy
|
phpinfo
|
???????????