← Back
Editing: mutable.cpython-312.pyc
� ���g�� � � � d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZ dd lmZ ddlmZ ddlmZ ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm Z ddlm 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%l0m1Z1 dd&l2m3Z3 dd'lm4Z4 dd(l5m6Z6 dd)l5m7Z7 ed*� Z8 ed+� Z9 G d,� d-� Z: G d.� d/e:� Z; G d0� d1e:� Z<d9d2�Z= e=� G d3� d4e;ee8e9f � Z> G d5� d6e;e e � Z? G d7� d8e;e e � Z@y):a�3 Provide support for tracking of in-place changes to scalar values, which are propagated into ORM change events on owning parent objects. .. _mutable_scalars: Establishing Mutability on Scalar Column Values =============================================== A typical example of a "mutable" structure is a Python dictionary. Following the example introduced in :ref:`types_toplevel`, we begin with a custom type that marshals Python dictionaries into JSON strings before being persisted:: from sqlalchemy.types import TypeDecorator, VARCHAR import json class JSONEncodedDict(TypeDecorator): "Represents an immutable structure as a json-encoded string." impl = VARCHAR def process_bind_param(self, value, dialect): if value is not None: value = json.dumps(value) return value def process_result_value(self, value, dialect): if value is not None: value = json.loads(value) return value The usage of ``json`` is only for the purposes of example. The :mod:`sqlalchemy.ext.mutable` extension can be used with any type whose target Python type may be mutable, including :class:`.PickleType`, :class:`_postgresql.ARRAY`, etc. When using the :mod:`sqlalchemy.ext.mutable` extension, the value itself tracks all parents which reference it. Below, we illustrate a simple version of the :class:`.MutableDict` dictionary object, which applies the :class:`.Mutable` mixin to a plain Python dictionary:: from sqlalchemy.ext.mutable import Mutable class MutableDict(Mutable, dict): @classmethod def coerce(cls, key, value): "Convert plain dictionaries to MutableDict." if not isinstance(value, MutableDict): if isinstance(value, dict): return MutableDict(value) # this call will raise ValueError return Mutable.coerce(key, value) else: return value def __setitem__(self, key, value): "Detect dictionary set events and emit change events." dict.__setitem__(self, key, value) self.changed() def __delitem__(self, key): "Detect dictionary del events and emit change events." dict.__delitem__(self, key) self.changed() The above dictionary class takes the approach of subclassing the Python built-in ``dict`` to produce a dict subclass which routes all mutation events through ``__setitem__``. There are variants on this approach, such as subclassing ``UserDict.UserDict`` or ``collections.MutableMapping``; the part that's important to this example is that the :meth:`.Mutable.changed` method is called whenever an in-place change to the datastructure takes place. We also redefine the :meth:`.Mutable.coerce` method which will be used to convert any values that are not instances of ``MutableDict``, such as the plain dictionaries returned by the ``json`` module, into the appropriate type. Defining this method is optional; we could just as well created our ``JSONEncodedDict`` such that it always returns an instance of ``MutableDict``, and additionally ensured that all calling code uses ``MutableDict`` explicitly. When :meth:`.Mutable.coerce` is not overridden, any values applied to a parent object which are not instances of the mutable type will raise a ``ValueError``. Our new ``MutableDict`` type offers a class method :meth:`~.Mutable.as_mutable` which we can use within column metadata to associate with types. This method grabs the given type object or class and associates a listener that will detect all future mappings of this type, applying event listening instrumentation to the mapped attribute. Such as, with classical table metadata:: from sqlalchemy import Table, Column, Integer my_data = Table( "my_data", metadata, Column("id", Integer, primary_key=True), Column("data", MutableDict.as_mutable(JSONEncodedDict)), ) Above, :meth:`~.Mutable.as_mutable` returns an instance of ``JSONEncodedDict`` (if the type object was not an instance already), which will intercept any attributes which are mapped against this type. Below we establish a simple mapping against the ``my_data`` table:: from sqlalchemy.orm import DeclarativeBase from sqlalchemy.orm import Mapped from sqlalchemy.orm import mapped_column class Base(DeclarativeBase): pass class MyDataClass(Base): __tablename__ = "my_data" id: Mapped[int] = mapped_column(primary_key=True) data: Mapped[dict[str, str]] = mapped_column( MutableDict.as_mutable(JSONEncodedDict) ) The ``MyDataClass.data`` member will now be notified of in place changes to its value. Any in-place changes to the ``MyDataClass.data`` member will flag the attribute as "dirty" on the parent object:: >>> from sqlalchemy.orm import Session >>> sess = Session(some_engine) >>> m1 = MyDataClass(data={"value1": "foo"}) >>> sess.add(m1) >>> sess.commit() >>> m1.data["value1"] = "bar" >>> assert m1 in sess.dirty True The ``MutableDict`` can be associated with all future instances of ``JSONEncodedDict`` in one step, using :meth:`~.Mutable.associate_with`. This is similar to :meth:`~.Mutable.as_mutable` except it will intercept all occurrences of ``MutableDict`` in all mappings unconditionally, without the need to declare it individually:: from sqlalchemy.orm import DeclarativeBase from sqlalchemy.orm import Mapped from sqlalchemy.orm import mapped_column MutableDict.associate_with(JSONEncodedDict) class Base(DeclarativeBase): pass class MyDataClass(Base): __tablename__ = "my_data" id: Mapped[int] = mapped_column(primary_key=True) data: Mapped[dict[str, str]] = mapped_column(JSONEncodedDict) Supporting Pickling -------------------- The key to the :mod:`sqlalchemy.ext.mutable` extension relies upon the placement of a ``weakref.WeakKeyDictionary`` upon the value object, which stores a mapping of parent mapped objects keyed to the attribute name under which they are associated with this value. ``WeakKeyDictionary`` objects are not picklable, due to the fact that they contain weakrefs and function callbacks. In our case, this is a good thing, since if this dictionary were picklable, it could lead to an excessively large pickle size for our value objects that are pickled by themselves outside of the context of the parent. The developer responsibility here is only to provide a ``__getstate__`` method that excludes the :meth:`~MutableBase._parents` collection from the pickle stream:: class MyMutableType(Mutable): def __getstate__(self): d = self.__dict__.copy() d.pop("_parents", None) return d With our dictionary example, we need to return the contents of the dict itself (and also restore them on __setstate__):: class MutableDict(Mutable, dict): # .... def __getstate__(self): return dict(self) def __setstate__(self, state): self.update(state) In the case that our mutable value object is pickled as it is attached to one or more parent objects that are also part of the pickle, the :class:`.Mutable` mixin will re-establish the :attr:`.Mutable._parents` collection on each value object as the owning parents themselves are unpickled. Receiving Events ---------------- The :meth:`.AttributeEvents.modified` event handler may be used to receive an event when a mutable scalar emits a change event. This event handler is called when the :func:`.attributes.flag_modified` function is called from within the mutable extension:: from sqlalchemy.orm import DeclarativeBase from sqlalchemy.orm import Mapped from sqlalchemy.orm import mapped_column from sqlalchemy import event class Base(DeclarativeBase): pass class MyDataClass(Base): __tablename__ = "my_data" id: Mapped[int] = mapped_column(primary_key=True) data: Mapped[dict[str, str]] = mapped_column( MutableDict.as_mutable(JSONEncodedDict) ) @event.listens_for(MyDataClass.data, "modified") def modified_json(instance, initiator): print("json value modified:", instance.data) .. _mutable_composites: Establishing Mutability on Composites ===================================== Composites are a special ORM feature which allow a single scalar attribute to be assigned an object value which represents information "composed" from one or more columns from the underlying mapped table. The usual example is that of a geometric "point", and is introduced in :ref:`mapper_composite`. As is the case with :class:`.Mutable`, the user-defined composite class subclasses :class:`.MutableComposite` as a mixin, and detects and delivers change events to its parents via the :meth:`.MutableComposite.changed` method. In the case of a composite class, the detection is usually via the usage of the special Python method ``__setattr__()``. In the example below, we expand upon the ``Point`` class introduced in :ref:`mapper_composite` to include :class:`.MutableComposite` in its bases and to route attribute set events via ``__setattr__`` to the :meth:`.MutableComposite.changed` method:: import dataclasses from sqlalchemy.ext.mutable import MutableComposite @dataclasses.dataclass class Point(MutableComposite): x: int y: int def __setattr__(self, key, value): "Intercept set events" # set the attribute object.__setattr__(self, key, value) # alert all parents to the change self.changed() The :class:`.MutableComposite` class makes use of class mapping events to automatically establish listeners for any usage of :func:`_orm.composite` that specifies our ``Point`` type. Below, when ``Point`` is mapped to the ``Vertex`` class, listeners are established which will route change events from ``Point`` objects to each of the ``Vertex.start`` and ``Vertex.end`` attributes:: from sqlalchemy.orm import DeclarativeBase, Mapped from sqlalchemy.orm import composite, mapped_column class Base(DeclarativeBase): pass class Vertex(Base): __tablename__ = "vertices" id: Mapped[int] = mapped_column(primary_key=True) start: Mapped[Point] = composite( mapped_column("x1"), mapped_column("y1") ) end: Mapped[Point] = composite( mapped_column("x2"), mapped_column("y2") ) def __repr__(self): return f"Vertex(start={self.start}, end={self.end})" Any in-place changes to the ``Vertex.start`` or ``Vertex.end`` members will flag the attribute as "dirty" on the parent object: .. sourcecode:: python+sql >>> from sqlalchemy.orm import Session >>> sess = Session(engine) >>> v1 = Vertex(start=Point(3, 4), end=Point(12, 15)) >>> sess.add(v1) {sql}>>> sess.flush() BEGIN (implicit) INSERT INTO vertices (x1, y1, x2, y2) VALUES (?, ?, ?, ?) [...] (3, 4, 12, 15) {stop}>>> v1.end.x = 8 >>> assert v1 in sess.dirty True {sql}>>> sess.commit() UPDATE vertices SET x2=? WHERE vertices.id = ? [...] (8, 1) COMMIT Coercing Mutable Composites --------------------------- The :meth:`.MutableBase.coerce` method is also supported on composite types. In the case of :class:`.MutableComposite`, the :meth:`.MutableBase.coerce` method is only called for attribute set operations, not load operations. Overriding the :meth:`.MutableBase.coerce` method is essentially equivalent to using a :func:`.validates` validation routine for all attributes which make use of the custom composite type:: @dataclasses.dataclass class Point(MutableComposite): # other Point methods # ... def coerce(cls, key, value): if isinstance(value, tuple): value = Point(*value) elif not isinstance(value, Point): raise ValueError("tuple or Point expected") return value Supporting Pickling -------------------- As is the case with :class:`.Mutable`, the :class:`.MutableComposite` helper class uses a ``weakref.WeakKeyDictionary`` available via the :meth:`MutableBase._parents` attribute which isn't picklable. If we need to pickle instances of ``Point`` or its owning class ``Vertex``, we at least need to define a ``__getstate__`` that doesn't include the ``_parents`` dictionary. Below we define both a ``__getstate__`` and a ``__setstate__`` that package up the minimal form of our ``Point`` class:: @dataclasses.dataclass class Point(MutableComposite): # ... def __getstate__(self): return self.x, self.y def __setstate__(self, state): self.x, self.y = state As with :class:`.Mutable`, the :class:`.MutableComposite` augments the pickling process of the parent's object-relational state so that the :meth:`MutableBase._parents` collection is restored to all ``Point`` objects. � )� annotations)� defaultdict)� AbstractSet)�Any)�Dict)�Iterable)�List)�Optional)�overload)�Set)�Tuple)� TYPE_CHECKING)�TypeVar)�UnionN)�WeakKeyDictionary� )�event)�inspect)�types)�util)�Mapper)�_ExternalEntityType)�_O)�_T)�AttributeEventToken)� flag_modified)�InstrumentedAttribute)�QueryableAttribute)� QueryContext)� DeclarativeAttributeIntercept)� InstanceState)�UOWTransaction)�_TypeEngineArgument)�SchemaEventTarget)�Column)� TypeEngine)�memoized_property)� SupportsIndex)� TypeGuard�_KT�_VTc �h � e Zd ZdZedd�� Zedd�� Zed d�� Ze d d�� Z y) � MutableBasezPCommon base class to :class:`.Mutable` and :class:`.MutableComposite`. c �* � t j � S )a� Dictionary of parent object's :class:`.InstanceState`->attribute name on the parent. This attribute is a so-called "memoized" property. It initializes itself with a new ``weakref.WeakKeyDictionary`` the first time it is accessed, returning the same object upon subsequent access. .. versionchanged:: 1.4 the :class:`.InstanceState` is now used as the key in the weak dictionary rather than the instance itself. )�weakrefr ��selfs �G/opt/hc_python/lib64/python3.12/site-packages/sqlalchemy/ext/mutable.py�_parentszMutableBase._parents� s � � �(�(�*�*� c �> � |�yd}t ||t |� fz � �)a� Given a value, coerce it into the target type. Can be overridden by custom subclasses to coerce incoming data into a particular type. By default, raises ``ValueError``. This method is called in different scenarios depending on if the parent class is of type :class:`.Mutable` or of type :class:`.MutableComposite`. In the case of the former, it is called for both attribute-set operations as well as during ORM loading operations. For the latter, it is only called during attribute-set operations; the mechanics of the :func:`.composite` construct handle coercion during load operations. :param key: string name of the ORM-mapped attribute being set. :param value: the incoming value. :return: the method should return the coerced value, or raise ``ValueError`` if the coercion cannot be completed. Nz1Attribute '%s' does not accept objects of type %s)� ValueError�type)�cls�key�value�msgs r2 �coercezMutableBase.coerce� s* � �0 �=��A�����T�%�[� 1�1�2�2r4 c � � |j hS )a� Given a descriptor attribute, return a ``set()`` of the attribute keys which indicate a change in the state of this attribute. This is normally just ``set([attribute.key])``, but can be overridden to provide for additional keys. E.g. a :class:`.MutableComposite` augments this set with the attribute keys associated with the columns that comprise the composite value. This collection is consulted in the case of intercepting the :meth:`.InstanceEvents.refresh` and :meth:`.InstanceEvents.refresh_flush` events, which pass along a list of attribute names that have been refreshed; the list is compared against this set to determine if action needs to be taken. )r9 �r8 � attributes r2 �_get_listen_keysz MutableBase._get_listen_keys� s � �" � � �� r4 c �l � ��� � � |j �||j ury|j }� j |� � d� ��fd� � d� � fd� } d� �fd� } d�fd� } d�fd� }t j |d� dd� � t j |d � dd� � t j |d |dd� � t j |d |dd� � t j |d |ddd�� t j |d|dd� � t j |d|dd� � y)�]Establish this type as a mutation listener for the given mapped descriptor. Nc � �� | j j �d� }|�3�r!�j �|� }|| j �< �|j | < yy)z�Listen for objects loaded or refreshed. Wrap the target data member's value with ``Mutable``. N)�dict�getr< r3 )�state�args�valr8 r< r9 s ���r2 �loadz.MutableBase._listen_on_attribute.<locals>.load sQ �� � �*�*�.�.��d�+�C���� �*�*�S�#�.�C�&)�E�J�J�s�O�&)�� � �U�#� r4 c �> �� |r�j |� r �| � y y �N)� intersection)rF �ctx�attrs� listen_keysrI s ��r2 � load_attrsz4MutableBase._listen_on_attribute.<locals>.load_attrs s! �� � �K� 4� 4�U� ;��U� � <r4 c �� �� ||u r|S t |�� s�j �|� }|��|j | < t |�� r%|j j t | � d� |S )z�Listen for set/replace events on the target data member. Establish a weak reference to the parent object on the incoming value, remove it for the one outgoing. N)� isinstancer< r3 �popr )�targetr: �oldvalue� initiatorr8 r9 s ��r2 �set_z.MutableBase._listen_on_attribute.<locals>.set_ si �� � �� � � � �e�S�)�� � �3��.��� �),����v�&��(�C�(��!�!�%�%�g�f�o�t�<��Lr4 c � �� | j j �d � }|�.d|vrt t � |d< |d � j |� y y �Nzext.mutable.values)rD rE r �list�append)rF � state_dictrH r9 s �r2 �picklez0MutableBase._listen_on_attribute.<locals>.pickle3 sT �� � �*�*�.�.��d�+�C���'�z�9�7B�4�7H�J� 3�4��/�0��5�<�<�S�A� r4 c � �� d|v rI|d }t |t � r|D ] }�|j | < � y |d � D ] }�|j | < � y y rY )rR rZ r3 )rF r\ � collectionrH r9 s �r2 �unpicklez2MutableBase._listen_on_attribute.<locals>.unpickle< se �� � $�z�1� '�(<� =� � �j�$�/� )��.1�� � �U�+� *� *�*>� ?�� D��.1�� � �U�+� E� 2r4 �_sa_event_merge_wo_loadT)�raw� propagaterI �refresh� refresh_flush�set)rb �retvalrc r] r` )rF �InstanceState[_O]rG r �return�None)rF rh rM z+Union[object, QueryContext, UOWTransaction]rN � Iterable[Any]ri rj ) rT rh r: �MutableBase | NonerU rl rV r ri rl )rF rh r\ zDict[str, Any]ri rj )r9 �class_r@ r �listen) r8 r? r< � parent_clsrP rW r] r` r9 rO rI s ` ` @@@r2 �_listen_on_attributez MutableBase._listen_on_attribute� s� �� � �m�m�� �Y� -� -� -� � �%�%� ��*�*�9�5� � *� �$� �<� � !� � � � �%� �%� � )� � +� � � �2 B�$� B�2@� B� � B� 2�$� 2�2@� 2� � 2� � � � � %� ��� � � � �Z���4�4�H� � � � � �:�4�4� � � � � ����� � � � � �u�d��T�T� � � � �Z��6�t�t�L� � � � � �H�$�$� r4 N)ri zWeakKeyDictionary[Any, Any])r9 �strr: r ri z Optional[Any])r? �QueryableAttribute[Any]ri �Set[str])r? rr r< �boolro z_ExternalEntityType[Any]ri rj ) �__name__� __module__� __qualname__�__doc__r' r3 � classmethodr< r@ rp � r4 r2 r- r- � s� � �� �+� �+� �3� �3�8 � � � �$ �m �*�m � �m � -� m � � m � �m r4 r- c �V � e Zd ZdZdd�Ze dd�� Zed d�� Zed d�� Zy) �Mutablez�Mixin that defines transparent propagation of change events to a parent object. See the example in :ref:`mutable_scalars` for usage information. c �| � | j j � D ] \ }}t |j � |� �! y�z@Subclasses should call this method whenever change events occur.N)r3 �itemsr �obj)r1 �parentr9 s r2 �changedzMutable.changedi s/ � � �=�=�.�.�0�K�F�C� �&�*�*�,�� ,� 1r4 c �> � | j |d|j � y)rB TN)rp rm r> s r2 �associate_with_attributez Mutable.associate_with_attributeo s � � � � ��D�)�2B�2B�Cr4 c �L � �� d� �fd� }t j t d|� y)a Associate this wrapper with all future mapped columns of the given type. This is a convenience method that calls ``associate_with_attribute`` automatically. .. warning:: The listeners established by this method are *global* to all mappers, and are *not* garbage collected. Only use :meth:`.associate_with` for types that are permanent to an application, not with ad-hoc types else this will cause unbounded growth in memory usage. c �� �� | j ry | j D ]K }t |j d j �� s�'�j t ||j � � �M y )Nr )� non_primary� column_attrsrR �columnsr7 r� �getattrr9 )�mapperrm �propr8 �sqltypes ��r2 �listen_for_typez/Mutable.associate_with.<locals>.listen_for_type� sP �� ��!�!�� �+�+�� �d�l�l�1�o� 2� 2�G�<��0�0������1J�K� ,r4 �mapper_configuredN)r� z Mapper[_O]rm r7 ri rj )r rn r )r8 r� r� s `` r2 �associate_withzMutable.associate_withy s �� �$ L� � � �V� 0�/�Br4 c � � ��� t j �� �t �t � r&t j �d� dd�� }d�nd� d� ��fd� }t j t d|� �S ) a? Associate a SQL type with this mutable Python type. This establishes listeners that will detect ORM mappings against the given type, adding mutation event trackers to those mappings. The type is returned, unconditionally as an instance, so that :meth:`.as_mutable` can be used inline:: Table( "mytable", metadata, Column("id", Integer, primary_key=True), Column("data", MyMutableType.as_mutable(PickleType)), ) Note that the returned type is always an instance, even if a class is given, and that only columns which are declared specifically with that type instance receive additional instrumentation. To associate a particular mutable type with all occurrences of a particular type, use the :meth:`.Mutable.associate_with` classmethod of the particular :class:`.Mutable` subclass to establish a global association. .. warning:: The listeners established by this method are *global* to all mappers, and are *not* garbage collected. Only use :meth:`.as_mutable` for types that are permanent to an application, not with ad-hoc types else this will cause unbounded growth in memory usage. �before_parent_attachc �" � | |j d< y )N�_ext_mutable_orig_type)�info)�sqltypr� s r2 �_add_column_memoz,Mutable.as_mutable.<locals>._add_column_memo� s � � 9?�� � � 4�5r4 TFc �� �� | j ry d}| j D ]� }t |j t � s� �r'|j j j d� �u s|j j �u s�`|j j j |d� r��d|j j |< �j t ||j � � �� y )N� _ext_mutable_listener_appliedr� FT) r� r� rR � expressionr% r� rE r7 r� r� r9 )r� rm � _APPLIED_KEYr� r8 �schema_event_checkr� s ���r2 r� z+Mutable.as_mutable.<locals>.listen_for_type� s� �� � �!�!��:�L� �+�+�� �t����7� /� $��� 4� 4� 8� 8� 8�! � '�!'� �?�?�/�/�7�:� �?�?�/�/�3�3�L�%�H�=A����,�,�\�:��4�4�W�V�T�X�X�5N�O�' ,r4 r� )r� zTypeEngine[Any]r� z Column[_T]ri rj )r� � Mapper[_T]rm z*Union[DeclarativeAttributeIntercept, type]ri rj )r � to_instancerR r$ r � listens_forrn r )r8 r� r� r� r� s `` @r2 � as_mutablezMutable.as_mutable� s� �� �F �#�#�G�,�� �g� 0� 1� � � �w�(>� ?� ?�'� ?�"� ?� � ?� @� ?� "&� �!&� � P� � P�>� P� � P�: � � �V� 0�/�B��r4 N�ri rj )r? zInstrumentedAttribute[_O]ri rj )r� r7 ri rj )r� z_TypeEngineArgument[_T]ri zTypeEngine[_T]) ru rv rw rx r� ry r� r� r� rz r4 r2 r| r| a s` � ��-� �D�1�D� �D� �D� �C� �C�4 �S� �Sr4 r| c �* � e Zd ZdZedd�� Zdd�Zy)�MutableCompositez�Mixin that defines transparent propagation of change events on a SQLAlchemy "composite" object to its owning parent or parents. See the example in :ref:`mutable_composites` for usage information. c �b � |j hj |j j � S rK )r9 �union�property�_attribute_keysr> s r2 r@ z!MutableComposite._get_listen_keys� s% � �� � ��$�$�Y�%7�%7�%G�%G�H�Hr4 c � � | j j � D ]h \ }}|j j |� }t |j | � |j � D ] \ }}t |j � ||� �" �j yr~ ) r3 r r� � get_property�zip� _composite_values_from_instancer� �setattrr� )r1 r� r9 r� r: � attr_names r2 r� zMutableComposite.changed� sr � � �=�=�.�.�0�K�F�C��=�=�-�-�c�2�D�$'��4�4�T�:��$�$�%� ��y� �� � � �i��7� %� 1r4 N)r? zQueryableAttribute[_O]ri rs r� )ru rv rw rx ry r@ r� rz r4 r2 r� r� � s" � �� �I� �I� 8r4 r� c �z � dd�} t j t d| � s t j t d| � y y )Nc � � | j D ]v }t |d� s�t |j t � s�+t |j t � s�F|j j t ||j � d|� �x y )N�composite_classF) �iterate_properties�hasattrrR r� r7 � issubclassr� rp r� r9 )r� rm r� s r2 �_listen_for_typez3_setup_composite_listener.<locals>._listen_for_type sd � ��-�-�D��� /�0� �t� 3� 3�T�:� �t� 3� 3�5E�F��$�$�9�9��F�D�H�H�-�u�f�� .r4 r� )r� r� rm r7 ri rj )r �containsr rn )r� s r2 �_setup_composite_listenerr� s3 � � � �>�>�&�"5�7G� H� � � �V� 0�2B�C� Ir4 c � � � e Zd ZdZd� fd� Zer!e d dd�� Zedd�� Zddd�Zn� fd�Zd� fd� Zd� fd� Z er edd �� Z edd �� Z d dd �Z n� fd �Z d � fd � Z d � fd� Z e d d�� Zd d�Z d d�Z� xZS )!� MutableDictaj A dictionary type that implements :class:`.Mutable`. The :class:`.MutableDict` object implements a dictionary that will emit change events to the underlying mapping when the contents of the dictionary are altered, including when values are added or removed. Note that :class:`.MutableDict` does **not** apply mutable tracking to the *values themselves* inside the dictionary. Therefore it is not a sufficient solution for the use case of tracking deep changes to a *recursive* dictionary structure, such as a JSON structure. To support this use case, build a subclass of :class:`.MutableDict` that provides appropriate coercion to the values placed in the dictionary so that they too are "mutable", and emit events up to their parent structure. .. seealso:: :class:`.MutableList` :class:`.MutableSet` c �F �� t �| � ||� | j � y)z4Detect dictionary set events and emit change events.N)�super� __setitem__r� )r1 r9 r: � __class__s �r2 r� zMutableDict.__setitem__. s �� � ���C��'� � � �r4 c � � y rK rz �r1 r9 r: s r2 � setdefaultzMutableDict.setdefault6 s � � r4 c � � y rK rz r� s r2 r� zMutableDict.setdefault; s � �;>r4 c � � y rK rz r� s r2 r� zMutableDict.setdefault> s � �r4 c �@ �� t �| � |� }| j � |S rK )r� r� r� �r1 �arg�resultr� s �r2 r� zMutableDict.setdefaultB s �� ��W�'��-�F� �L�L�N��Mr4 c �D �� t �| � |� | j � y)z4Detect dictionary del events and emit change events.N�r� � __delitem__r� )r1 r9 r� s �r2 r� zMutableDict.__delitem__G s �� � ���C� � � � �r4 c �D �� t �| � |i |�� | j � y rK �r� �updater� )r1 �a�kwr� s �r2 r� zMutableDict.updateL s �� � ���� �R� � � � �r4 c � � y rK rz )r1 �_MutableDict__keys r2 rS zMutableDict.popR s � �*-r4 c � � y rK rz �r1 r� �_MutableDict__defaults r2 rS zMutableDict.popU s � �DGr4 c � � y rK rz r� s r2 rS zMutableDict.popX s � �r4 c �@ �� t �| � |� }| j � |S rK �r� rS r� r� s �r2 rS zMutableDict.pop^ s �� ��W�[�#�&�F� �L�L�N��Mr4 c �D �� t �| � � }| j � |S rK )r� �popitemr� )r1 r� r� s �r2 r� zMutableDict.popitemc s �� ��� �"�� � � ��� r4 c �B �� t �| � � | j � y rK �r� �clearr� �r1 r� s �r2 r� zMutableDict.clearh � �� � �� �� � � �r4 c �z � t || � s.t |t � r | |� S t j ||� S |S )z3Convert plain dictionary to instance of this class.)rR rD r| r< �r8 r9 r: s r2 r< zMutableDict.coercel s8 � � �%��%��%��&��5�z�!��>�>�#�u�-� -��Lr4 c � � t | � S rK )rD r0 s r2 � __getstate__zMutableDict.__getstate__v s � ��D�z�r4 c �& � | j |� y rK �r� �r1 rF s r2 � __setstate__zMutableDict.__setstate__y s � � � � �E�r4 )r9 r* r: r+ ri rj rK )r1 z MutableDict[_KT, Optional[_T]]r9 r* r: rj ri z Optional[_T])r9 r* r: r+ ri r+ )r9 r* r: �objectri r� )r9 r* ri rj )r� r r� r+ ri rj )r� r* ri r+ )r� r* r� �_VT | _Tri r� )r� r* r� z_VT | _T | Noneri r� )ri zTuple[_KT, _VT]r� )r9 rq r: r ri z MutableDict[_KT, _VT] | None)ri zDict[_KT, _VT])rF z%Union[Dict[str, int], Dict[str, str]]ri rj )ru rv rw rx r� r r r� r� r� rS r� r� ry r< r� r� � __classcell__�r� s @r2 r� r� s� �� ��,� � �JN� �0� �7:� �CG� � � � � � �>� �>�K� � � � � �-� �-� �G� �G� <@� � � �)8� � � � � � � �� ����:�� �r4 r� c �� � � e Zd ZdZ dd�Zdd�Zdd�Zdd�Z d� fd� Zd� fd� Z d� fd� Z d� fd � Z d� fd � Z dd �Z d � fd � Zd � fd � Zd � fd� Zd � fd� Zd � fd� Ze d d�� Z� xZS )!� MutableListaO A list type that implements :class:`.Mutable`. The :class:`.MutableList` object implements a list that will emit change events to the underlying mapping when the contents of the list are altered, including when values are added or removed. Note that :class:`.MutableList` does **not** apply mutable tracking to the *values themselves* inside the list. Therefore it is not a sufficient solution for the use case of tracking deep changes to a *recursive* mutable structure, such as a JSON structure. To support this use case, build a subclass of :class:`.MutableList` that provides appropriate coercion to the values placed in the dictionary so that they too are "mutable", and emit events up to their parent structure. .. seealso:: :class:`.MutableDict` :class:`.MutableSet` c �2 � | j t | � ffS rK �r� rZ �r1 �protos r2 � __reduce_ex__zMutableList.__reduce_ex__� � � � ����d�� �.�.r4 c � � || d d y rK rz r� s r2 r� zMutableList.__setstate__� s � ���Q�r4 c �. � t j |� S rK �r �is_non_string_iterable�r1 r: s r2 � is_scalarzMutableList.is_scalar� s � ��.�.�u�5�5�5r4 c �, � t j |� S rK r� r� s r2 � is_iterablezMutableList.is_iterable� s � ��*�*�5�1�1r4 c �� �� t |t � r"| j |� rt �| � ||� n1t |t � r!| j |� rt �| � ||� | j � y)z.Detect list set events and emit change events.N)rR r( r� r� r� �slicer� r� )r1 �indexr: r� s �r2 r� zMutableList.__setitem__� sX �� � �e�]� +����u�0E� �G� ��u� -� ��u� %�$�*:�*:�5�*A� �G� ��u� -� � � �r4 c �D �� t �| � |� | j � y)z.Detect list del events and emit change events.Nr� )r1 r� r� s �r2 r� zMutableList.__delitem__� s �� � ���E�"� � � �r4 c �@ �� t �| � |� }| j � |S rK r� r� s �r2 rS zMutableList.pop� � �� ����c�"�� � � ��� r4 c �D �� t �| � |� | j � y rK )r� r[ r� �r1 �xr� s �r2 r[ zMutableList.append� � �� � ���q�� � � �r4 c �D �� t �| � |� | j � y rK )r� �extendr� r s �r2 r zMutableList.extend� r r4 c �( � | j |� | S rK )r )r1 r s r2 �__iadd__zMutableList.__iadd__� s � � � � �A��� r4 c �F �� t �| � ||� | j � y rK )r� �insertr� )r1 �ir r� s �r2 r zMutableList.insert� s �� � ���q�!� � � � �r4 c �D �� t �| � |� | j � y rK �r� �remover� )r1 r r� s �r2 r zMutableList.remove� r r4 c �B �� t �| � � | j � y rK r� r� s �r2 r� zMutableList.clear� r� r4 c �D �� t �| � di |�� | j � y )Nrz )r� �sortr� )r1 r� r� s �r2 r zMutableList.sort� s �� � �� ��r�� � � �r4 c �B �� t �| � � | j � y rK )r� �reverser� r� s �r2 r zMutableList.reverse� s �� � ���� � � �r4 c �z � t || � s.t |t � r | |� S t j ||� S |S )z-Convert plain list to instance of this class.)rR rZ r| r< r� s r2 r< zMutableList.coerce� s8 � � �%��%��%��&��5�z�!��>�>�#�u�-� -��Lr4 �r� r( ri z Tuple[type, Tuple[List[int]]]�rF � Iterable[_T]ri rj )r: �_T | Iterable[_T]ri z TypeGuard[_T])r: r ri zTypeGuard[Iterable[_T]])r� �SupportsIndex | slicer: r ri rj )r� r ri rj )r� r( ri r )r r ri rj )r r ri rj )r r ri zMutableList[_T])r r( r r ri rj )r r ri rj r� )r� r ri rj )r9 rq r: zMutableList[_T] | _Tri zOptional[MutableList[_T]])ru rv rw rx r� r� r� r� r� r� rS r[ r r r r r� r r ry r< r� r� s @r2 r� r� s� �� ��,/�"�/� &�/��6�2��*��3D�� ��� � �������� � �� � 2� � "� � � r4 r� c �� � � e Zd ZdZd� fd� Zd� fd� Zd� fd� Zd� fd� Zdd�Zdd�Z dd�Z dd �Z d� fd � Z d� fd � Z d� fd � Zd� fd � Zd� fd� Zedd�� Zdd�Zd d�Z d d�Z� xZS ) � MutableSeta0 A set type that implements :class:`.Mutable`. The :class:`.MutableSet` object implements a set that will emit change events to the underlying mapping when the contents of the set are altered, including when values are added or removed. Note that :class:`.MutableSet` does **not** apply mutable tracking to the *values themselves* inside the set. Therefore it is not a sufficient solution for the use case of tracking deep changes to a *recursive* mutable structure. To support this use case, build a subclass of :class:`.MutableSet` that provides appropriate coercion to the values placed in the dictionary so that they too are "mutable", and emit events up to their parent structure. .. seealso:: :class:`.MutableDict` :class:`.MutableList` c �> �� t �| � |� | j � y rK r� �r1 r� r� s �r2 r� zMutableSet.update� s �� � ���� � � � �r4 c �> �� t �| � |� | j � y rK )r� �intersection_updater� r s �r2 r z MutableSet.intersection_update s �� � ��#�S�)� � � �r4 c �> �� t �| � |� | j � y rK )r� �difference_updater� r s �r2 r z MutableSet.difference_update s �� � ��!�3�'� � � �r4 c �> �� t �| � |� | j � y rK )r� �symmetric_difference_updater� r s �r2 r! z&MutableSet.symmetric_difference_update s �� � ��+�S�1� � � �r4 c �( � | j |� | S rK r� �r1 �others r2 �__ior__zMutableSet.__ior__ s � � � � �E��� r4 c �( � | j |� | S rK )r r# s r2 �__iand__zMutableSet.__iand__ s � � � � ��'�� r4 c �( � | j |� | S rK )r! r# s r2 �__ixor__zMutableSet.__ixor__ s � � �(�(��/�� r4 c �( � | j |� | S rK )r r# s r2 �__isub__zMutableSet.__isub__ s � � � � �u�%�� r4 c �D �� t �| � |� | j � y rK )r� �addr� �r1 �elemr� s �r2 r- zMutableSet.add s �� � �� �D�� � � �r4 c �D �� t �| � |� | j � y rK r r. s �r2 r zMutableSet.remove# s �� � ���t� � � � �r4 c �D �� t �| � |� | j � y rK )r� �discardr� r. s �r2 r2 zMutableSet.discard' s �� � ���� � � � �r4 c �@ �� t �| � |� }| j � |S rK r� r� s �r2 rS zMutableSet.pop+ r� r4 c �B �� t �| � � | j � y rK r� r� s �r2 r� zMutableSet.clear0 r� r4 c �z � t || � s.t |t � r | |� S t j ||� S |S )z,Convert plain set to instance of this class.)rR rf r| r< )r8 r� r: s r2 r< zMutableSet.coerce4 s8 � � �%��%��%��%��5�z�!��>�>�%��/� /��Lr4 c � � t | � S rK )rf r0 s r2 r� zMutableSet.__getstate__> s � ��4�y�r4 c �& � | j |� y rK r� r� s r2 r� zMutableSet.__setstate__A s � � � � �E�r4 c �2 � | j t | � ffS rK r� r� s r2 r� zMutableSet.__reduce_ex__D r� r4 )r� r ri rj )r� rk ri rj )r$ zAbstractSet[_T]ri �MutableSet[_T])r$ zAbstractSet[object]ri r9 )r/ r ri rj )r� r ri r r� )r� rq r: r ri zOptional[MutableSet[_T]])ri zSet[_T]r r )ru rv rw rx r� r r r! r% r' r) r+ r- r r2 rS r� ry r< r� r� r� r� r� s @r2 r r � s| �� ��.������������ � �� ����/�"�/� &�/r4 r r� )Arx � __future__r � collectionsr �typingr r r r r r r r r r r r r/ r � r r r r �ormr � orm._typingr r r �orm.attributesr r r r � orm.contextr � orm.decl_apir � orm.stater! �orm.unitofworkr" � sql._typingr# �sql.baser$ � sql.schemar% � sql.type_apir& r' � util.typingr( r) r* r+ r- r| r� r� r� r� r rz r4 r2 �<module>rJ s ��q�f #� #� � � � � � � � � � � � � � %� � � � � � -� � � 0� *� 2� /� &� 8� %� +� -� (� � %� $� '� #� �e�n�� �e�n��u � u �pG�k� G�T8�{� 8�2 D� � �e�'�4��S��>� e�Pe�'�4��8� e�P`/��#�b�'� `/r4
Save File
Cancel