U
|
¸ý°dG ã @ sX 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 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/m0Z0 dd%l1m2Z2 dd&l3m4Z4 dd'l3m5Z5 ed(Z6ed)Z7G d*d+ d+Z8G d,d- d-e8Z9G d.d/ d/e8Z:d0d1d2d3Z;e; G d4d5 d5e9ee6e7f Z<G d6d7 d7e9e
|
e Z=G d8d9 d9e9e e Z>dS ):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)ÚMapper)Ú_ExternalEntityType)Ú_O)Ú_T)ÚAttributeEventToken)Ú flag_modified)ÚInstrumentedAttribute)ÚQueryableAttribute)Ú QueryContext)Ú DeclarativeAttributeIntercept)Ú InstanceState)ÚUOWTransaction)ÚSchemaEventTarget)ÚColumn)Ú
|
TypeEngine)Úmemoized_property)Ú SupportsIndex)Ú TypeGuardÚ_KTÚ_VTc @ sd e Zd ZdZeddddZedddd d
|
d Zed d dddZed ddddddZ dS )Ú MutableBasezPCommon base class to :class:`.Mutable`
|
and :class:`.MutableComposite`.
|
|
zWeakKeyDictionary[Any, Any]©Úreturnc C s t ¡ 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 ©Úself© r/ úMd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/ext/mutable.pyÚ_parents s zMutableBase._parentsÚstrr z Optional[Any]©ÚkeyÚvaluer+ c C s( |dkr dS d}t ||t|f dS )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)Úclsr4 r5 Úmsgr/ r/ r0 Úcoerce« s zMutableBase.coercezQueryableAttribute[Any]úSet[str]©Ú attributer+ c C s |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.
|
|
©r4 ©r8 r= r/ r/ r0 Ú_get_listen_keysÈ s z MutableBase._get_listen_keysÚboolz_ExternalEntityType[Any]ÚNone)r= r: Ú
|
parent_clsr+ c s2 |j ||jk rdS |j} |¡dddd fdd ddd dd
|
fd d }dd d dd d fdd }ddddfdd }ddddfdd }tj|dddd tj|dddd tj|d |ddd tj|d |ddd tj|d |dddd tj|d |ddd tj|d!|ddd dS )"ú]Establish this type as a mutation listener for the given
|
mapped descriptor.
|
|
NzInstanceState[_O]r rB )ÚstateÚargsr+ c s> | j d¡}|dk r:r0 |¡}|| j < |j| < dS )zListen for objects loaded or refreshed.
|
|
Wrap the target data member's value with
|
``Mutable``.
|
|
N)ÚdictÚgetr: r1 )rE rF Úval)r8 r: r4 r/ r0 Úloadï s
|
z.MutableBase._listen_on_attribute.<locals>.loadz+Union[object, QueryContext, UOWTransaction]ú Iterable[Any])rE ÚctxÚattrsr+ c s |r |¡r| d S ©N)Ú intersection)rE rL rM )Ú listen_keysrJ r/ r0 Ú
|
load_attrsý s z4MutableBase._listen_on_attribute.<locals>.load_attrszMutableBase | Noner )Útargetr5 ÚoldvalueÚ initiatorr+ c sT ||kr |S t | s" |¡}|dk r4|j| < t | rP|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: r1 Úpopr )rR r5 rS rT )r8 r4 r/ r0 Úset_ s
|
|
|
z.MutableBase._listen_on_attribute.<locals>.set_zDict[str, Any])rE Ú
|
state_dictr+ c s@ | j d ¡}|d k r<d|kr*tt|d< |d |¡ d S ©Nzext.mutable.values)rG rH r ÚlistÚappend)rE rX rI r> r/ r0 Úpickle s
|
z0MutableBase._listen_on_attribute.<locals>.picklec sP d|krL|d }t |tr0|D ]} |j| < q n |d D ]} |j| < q<d S rY )rU rZ r1 )rE rX Z
|
collectionrI r> r/ r0 Úunpickle' s
|
z2MutableBase._listen_on_attribute.<locals>.unpickleZ_sa_event_merge_wo_loadT)ÚrawÚ propagaterJ ZrefreshZ refresh_flushÚset)r^ Úretvalr_ r\ r] )r4 Úclass_r@ r Úlisten)r8 r= r: rC rQ rW r\ r] r/ )r8 r: r4 rP rJ r0 Ú_listen_on_attributeÛ s`
|
|
û ÿ ÿ ÿ ÿz MutableBase._listen_on_attributeN)
|
Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r$ r1 Ú classmethodr: r@ rd r/ r/ r/ r0 r) s r) c @ sZ e Zd ZdZddddZeddddd Zed
|
dd d d Zeddd ddZdS )ÚMutablezMixin that defines transparent propagation of change
|
events to a parent object.
|
|
See the example in :ref:`mutable_scalars` for usage information.
|
|
rB r* c C s& | j ¡ D ]\}}t| ¡ | q
|
dS ©z@Subclasses should call this method whenever change events occur.N)r1 Úitemsr Úobj)r. Úparentr4 r/ r/ r0 ÚchangedT s zMutable.changedzInstrumentedAttribute[_O]r< c C s | |d|j¡ dS )rD TN)rd rb r? r/ r/ r0 Úassociate_with_attributeZ s z Mutable.associate_with_attributer7 )Úsqltyper+ c s* dddd fdd }t td|¡ dS ) 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.
|
|
z
|
Mapper[_O]r7 rB ©Úmapperrb r+ c s> | j r
|
d S | jD ](}t|jd jr t||j¡ qd S )Nr )Ú non_primaryÚ column_attrsrU Úcolumnsr7 rp Úgetattrr4 ©rs rb Úprop©r8 rq r/ r0 Úlisten_for_typev s
|
|
z/Mutable.associate_with.<locals>.listen_for_typeÚmapper_configuredN)r rc r )r8 rq r{ r/ rz r0 Úassociate_withd s zMutable.associate_withzTypeEngine[_T]c sh t ¡ttr8t d¡dddddd}dnd d
|
d dd fd d }t td|¡ 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.
|
|
Zbefore_parent_attachzTypeEngine[Any]z
|
Column[_T]rB )Úsqltyprn r+ c S s | |j d< d S )NÚ_ext_mutable_orig_type)Úinfo)r~ rn r/ r/ r0 Ú_add_column_memo§ s z,Mutable.as_mutable.<locals>._add_column_memoTFú
|
Mapper[_T]z*Union[DeclarativeAttributeIntercept, type]rr c sz | j r
|
d S d}| jD ]`}t|jtrr:|jj d¡ksF|jjkr|jj |d¡sd|jj|< t ||j
|
¡ qd S )NZ _ext_mutable_listener_appliedr FT) rt ru rU Z
|
expressionr" r rH r7 rp rw r4 )rs rb Z _APPLIED_KEYry ©r8 Zschema_event_checkrq r/ r0 r{ ² s&
|
|
üùÿýø
|
ó z+Mutable.as_mutable.<locals>.listen_for_typer| )r Z to_instancerU r! r Z listens_forrc r )r8 rq r r{ r/ r r0 Ú
|
as_mutable s !
|
|
|
zMutable.as_mutableN) re rf rg rh ro ri rp r} r r/ r/ r/ r0 rj L s rj c @ s2 e Zd ZdZedddddZddd d
|
Zd S ) Ú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.
|
|
zQueryableAttribute[_O]r; r< c C s |j h |jj¡S rN )r4 ÚunionÚpropertyÚ_attribute_keysr? r/ r/ r0 r@ Ý s z!MutableComposite._get_listen_keysrB r* c C sP | j ¡ D ]@\}}|j |¡}t| | ¡|jD ]\}}t| ¡ || q0q
|
dS rk ) r1 rl rs Z get_propertyÚzipZ _composite_values_from_instancer Úsetattrrm )r. rn r4 ry r5 Ú attr_namer/ r/ r0 ro á s þ zMutableComposite.changedN)re rf rg rh ri r@ ro r/ r/ r/ r0 r
Ô s r
rB r* c C s2 dddddd} t td| ¡s.t td| ¡ d S )Nr r7 rB rr c S sJ | j D ]>}t|drt|jtrt|jtr|j t||j d|¡ qd S )NÚcomposite_classF)
|
Ziterate_propertiesÚhasattrrU r r7 Ú
|
issubclassr
rd rw r4 rx r/ r/ r0 Ú_listen_for_typeî s
|
ÿ
|
þ
|
ý
|
ÿz3_setup_composite_listener.<locals>._listen_for_typer| )r Úcontainsr rc )r r/ r/ r0 Ú_setup_composite_listenerí s r c sR e Zd ZdZdddd fdd Zerled3d ddd
|
d d d Zedddddd Zd4dddddd Zn fdd Zddd fdd Zdddd fdd Z eræedddddZ
|
edd d d d dZ
|
d5dd d d d dZ
|
n fd!dZ
|
d"d# fd$d% Z dd# fd&d' Z e d(dd)dd*d+Zd,d#d-d.Zd/dd0d1d2Z ZS )6Ú 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`
|
|
r' r( rB r3 c s t ||¡ | ¡ dS )z4Detect dictionary set events and emit change events.N)ÚsuperÚ __setitem__ro ©r. r4 r5 ©Ú __class__r/ r0 r s zMutableDict.__setitem__Nz MutableDict[_KT, Optional[_T]]z Optional[_T])r. r4 r5 r+ c C s d S rN r/ r r/ r/ r0 Ú
|
setdefault s zMutableDict.setdefaultc C s d S rN r/ r r/ r/ r0 r % s Úobjectc C s d S rN r/ r r/ r/ r0 r ) s c s t j| }| ¡ |S rN )r r ro ©r. ÚargÚresultr r/ r0 r . s )r4 r+ c s t |¡ | ¡ dS )z4Detect dictionary del events and emit change events.N©r Ú __delitem__ro )r. r4 r r/ r0 r 3 s zMutableDict.__delitem__r )ÚaÚkwr+ c s t j|| | ¡ d S rN ©r Úupdatero )r. r r r r/ r0 r¢ 8 s zMutableDict.update)Ú_MutableDict__keyr+ c C s d S rN r/ )r. r£ r/ r/ r0 rV > s zMutableDict.popz_VT | _T)r£ Ú_MutableDict__defaultr+ c C s d S rN r/ ©r. r£ r¤ r/ r/ r0 rV B s z_VT | _T | Nonec C s d S rN r/ r¥ r/ r/ r0 rV F s c s t j| }| ¡ |S rN ©r rV ro r r r/ r0 rV M s zTuple[_KT, _VT]r* c s t ¡ }| ¡ |S rN )r Úpopitemro )r. r r r/ r0 r§ R s
|
zMutableDict.popitemc s t ¡ | ¡ d S rN ©r Úclearro r- r r/ r0 r© W s
|
zMutableDict.clearr2 z MutableDict[_KT, _VT] | Nonec C s0 t || s(t |tr | |S t ||¡S |S dS )z3Convert plain dictionary to instance of this class.N)rU rG rj r: ©r8 r4 r5 r/ r/ r0 r: [ s
|
|
|
zMutableDict.coercezDict[_KT, _VT]c C s t | S rN )rG r- r/ r/ r0 Ú __getstate__e s zMutableDict.__getstate__z%Union[Dict[str, int], Dict[str, str]]©rE r+ c C s | |¡ d S rN ©r¢ ©r. rE r/ r/ r0 Ú __setstate__h s zMutableDict.__setstate__)N)N)N)re rf rg rh r r r
|
r r r¢ rV r§ r© ri r: r« r¯ Ú __classcell__r/ r/ r r0 r s4 ÿ ÿ r c sB e Zd ZdZdddddZddd d
|
d Zd d dddZd ddddZdd dd fdd Zddd fdd Z ddd fd d Z
|
ddd fd d! Z ddd fd"d# Z dd$d d%d&Z dddd' fd(d) Zddd* fd+d, Zdd- fd.d/ Zd0dd1 fd2d3 Zdd- fd4d5 Zed6d7d8d9d:d;Z ZS )<Ú 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`
|
|
r% ú Tuple[type, Tuple[List[int]]]©Úprotor+ c C s | j t| ffS rN ©r rZ ©r. r´ r/ r/ r0 Ú __reduce_ex__
s zMutableList.__reduce_ex__ú Iterable[_T]rB r¬ c C s || d d
< d S rN r/ r® r/ r/ r0 r¯ s zMutableList.__setstate__z_T | Iterable[_T]z TypeGuard[_T])r5 r+ c C s t |t S rN ©rU r ©r. r5 r/ r/ r0 Ú is_scalar s zMutableList.is_scalarzTypeGuard[Iterable[_T]]c C s
|
t |tS rN r¹ rº r/ r/ r0 Ú is_iterable s zMutableList.is_iterablezSupportsIndex | slice©Úindexr5 r+ c sR t |tr$| |¡r$t ||¡ n"t |trF| |¡rFt ||¡ | ¡ dS )z.Detect list set events and emit change events.N)rU r% r» r r Úslicer¼ ro )r. r¾ r5 r r/ r0 r s
|
zMutableList.__setitem__)r¾ r+ c s t |¡ | ¡ dS )z.Detect list del events and emit change events.Nr )r. r¾ r r/ r0 r s zMutableList.__delitem__r ©r r+ c s t j| }| ¡ |S rN r¦ r r r/ r0 rV ¤ s zMutableList.pop)Úxr+ c s t |¡ | ¡ d S rN )r r[ ro ©r. rÁ r r/ r0 r[ © s zMutableList.appendc s t |¡ | ¡ d S rN )r Úextendro r r r/ r0 rà s zMutableList.extendzMutableList[_T]c C s | |¡ | S rN )rà r r/ r/ r0 Ú__iadd__± s
|
zMutableList.__iadd__)ÚirÁ r+ c s t ||¡ | ¡ d S rN )r Úinsertro )r. rÅ rÁ r r/ r0 rÆ µ s zMutableList.insert)rÅ r+ c s t |¡ | ¡ d S rN ©r Úremovero )r. rÅ r r/ r0 rÈ ¹ s zMutableList.remover* c s t ¡ | ¡ d S rN r¨ r- r r/ r0 r© ½ s
|
zMutableList.clearr )r r+ c s t jf | | ¡ d S rN )r Úsortro )r. r r r/ r0 rÉ Á s zMutableList.sortc s t ¡ | ¡ d S rN )r Úreversero r- r r/ r0 rÊ Å s
|
zMutableList.reverser2 zMutableList[_T] | _TzOptional[MutableList[_T]]r3 c C s0 t || s(t |tr | |S t ||¡S |S dS )z-Convert plain list to instance of this class.N)rU rZ rj r: rª r/ r/ r0 r: É s
|
|
|
zMutableList.coerce)re rf rg rh r· r¯ r» r¼ r r rV r[ rà rÄ rÆ rÈ r© rÉ rÊ ri r: r° r/ r/ r r0 r± n s$
|
r± c sJ e Zd ZdZddd fdd Zddd fdd Zddd fd
|
d Zddd fd d ZdddddZdddddZ dddddZ
|
dddddZ ddd fd d Z ddd fd d Z ddd fd d! Zd"dd fd#d$ Zdd% fd&d' Zed(d"d)d*d+d,Zd-d%d.d/Zddd0d1d2Zd3d4d5d6d7Z ZS )8Ú
|
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`
|
|
|
r¸ rB rÀ c s t j| | ¡ d S rN r¡ ©r. r r r/ r0 r¢ î s zMutableSet.updaterK c s t j| | ¡ d S rN )r Úintersection_updatero rÌ r r/ r0 rÍ ò s z MutableSet.intersection_updatec s t j| | ¡ d S rN )r Údifference_updatero rÌ r r/ r0 rÎ ö s z MutableSet.difference_updatec s t j| | ¡ d S rN )r Úsymmetric_difference_updatero rÌ r r/ r0 rÏ ú s z&MutableSet.symmetric_difference_updatezAbstractSet[_T]zMutableSet[_T])Úotherr+ c C s | |¡ | S rN r ©r. rÐ r/ r/ r0 Ú__ior__þ s
|
zMutableSet.__ior__zAbstractSet[object]c C s | |¡ | S rN )rÍ rÑ r/ r/ r0 Ú__iand__ s
|
zMutableSet.__iand__c C s | |¡ | S rN )rÏ rÑ r/ r/ r0 Ú__ixor__ s
|
zMutableSet.__ixor__c C s | |¡ | S rN )rÎ rÑ r/ r/ r0 Ú__isub__
|
s
|
zMutableSet.__isub__r )Úelemr+ c s t |¡ | ¡ d S rN )r Úaddro ©r. rÖ r r/ r0 r× s zMutableSet.addc s t |¡ | ¡ d S rN rÇ rØ r r/ r0 rÈ s zMutableSet.removec s t |¡ | ¡ d S rN )r Údiscardro rØ r r/ r0 rÙ s zMutableSet.discardr c s t j| }| ¡ |S rN r¦ r r r/ r0 rV s zMutableSet.popr* c s t ¡ | ¡ d S rN r¨ r- r r/ r0 r© s
|
zMutableSet.clearr2 zOptional[MutableSet[_T]]r½ c C s0 t || s(t |tr | |S t ||¡S |S dS )z,Convert plain set to instance of this class.N)rU r` rj r: )r8 r¾ r5 r/ r/ r0 r: # s
|
|
|
zMutableSet.coercezSet[_T]c C s t | S rN )r` r- r/ r/ r0 r« - s zMutableSet.__getstate__r¬ c C s | |¡ d S rN r r® r/ r/ r0 r¯ 0 s zMutableSet.__setstate__r% r² r³ c C s | j t| ffS rN rµ r¶ r/ r/ r0 r· 3 s zMutableSet.__reduce_ex__)re rf rg rh r¢ rÍ rÎ rÏ rÒ rÓ rÔ rÕ r× rÈ rÙ rV r© ri r: r« r¯ r· r° r/ r/ r r0 rË Ö s& rË )?rh Ú
|
__future__r Ú collectionsr Útypingr r r r r r r
|
r r r r r r, r Ú r r r Zormr Z orm._typingr r r Zorm.attributesr r r r Z orm.contextr Z orm.decl_apir Z orm.stater Zorm.unitofworkr Zsql.baser! Z
|
sql.schemar" Z sql.type_apir# Úutilr$ Z util.typingr% r& r' r( r) rj r
r r r± rË r/ r/ r/ r0 Ú<module> sf b 9 nh
|
