o

���gmk�@
s�dZd
dl
mZ
d
dlmZ
d
dlZd
dlZd
dlmZ
d
dlmZ
d
dlm	Z	
d
dlm
Z

d
d	lmZ
d
d
lmZ
d
dlm
Z

d
dlmZ
d
d
lmZ
d
dlmZ
d
dlmZ
d
dlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddl m!Z!
ddl"m#Z#
ejr�ddlm$Z$
ddlm%Z%
ddlm&Z&
dd l'm(Z(
dd!l)m*Z*
dd"l+m,Z,
dd#l-m.Z.
dd$l/m0Z0
dd%l1m2Z2
dd&lm3Z3
dd'l4m5Z5
dd(l6m7Z7
dd)l6m8Z8
dd*lm9Z9
dd+l:m;Z;
ed,ed-�Z<ed.ed/d0�Z=ed1e>d-�Z?Gd2d3�d3e�Z@eAe@�
\ZBZCZDZEZFeFZGGd4d5�d5e�ZHeHjI�J�\ZKZLZMZNZOZPZQZRZSZTZUZVZWZXZYZZZ[Z\d6Z]d7Z^Gd8d9�d9e�Z_eAe_�
\Z`ZaZbZcGd:d;�d;e�ZdeAed�
\ZeZfZgGd<d=�d=e�ZhGd>d?�d?eh�ZiejeGg
�
ZkejdeGeBg�
Zlejdg
�
Zme�nd@�
Zoe�ndA�
Zpe�ndB�
ZqedCedDefd-�ZredE�
Zsd�dJdK�Zte�
r�d�dOdP�Zue
d�dSdT��
Zve
d�dWdT��
Zvd�dXdT�Zvd�d[d\�Zwd�d_d`�ZxndadP�ZudbdT�Zve�ye^�
Zwe�ydc�
Zxd�dedf�Zzd�didj�Z{d�dkdl�Z|d�dndo�Z}d�dpdq�Z~d�dsdt�Zd�dvdw�Z�e��e>�
d�dydz��
Z�d�d}d~�Z�d�d�d��Z�d�d�d��Z�d�d�d��Z�ed�d�d���
Z�e�r1d�d�d��Z�ne��d��
Z�	�d�d�d�d��Z�d�d�d��Z�d�d�d�d��Z�Gd�d��d��Z�Gd�d��d�e��Z�Gd�d��d�ee=e!�Z�Gd�d��d�e
e=e!�Z�Gd�d��d�e
e=e!�Z�Gd�d��d�e�e=ee=e!�Z�Gd�d��d�e�e=e�e=e�e=ej��Z�Gd�d��d�e
e=e!�Z�Gd�d��d�e�e=e�e=�Z�Gd�d��d�e�e=�Z�Gd�d��d�e�e=�Z�dS)�z=Constants and rudimental functions used throughout the ORM.

�)
�annotations)
�EnumN)
�Any)
�Callable)
�Dict)
�Generic)
�
no_type_check)
�Optional)
�overload)
�Tuple)
�Type)
�
TYPE_CHECKING)
�TypeVar)
�Union�
)
�exc)
�insp_is_mapper�)
�
inspection)
�util)
�roles)
�SQLColumnExpression)
�SQLCoreOperations)
�FastIntFlag)
�
TypingOnly)
�Literal)
�_EntityType)
�_ExternalEntityType)
�_InternalEntityType)
�InstrumentedAttribute)
�
AppenderQuery)
�ClassManager)
�PropComparator)
�Mapper)
�
InstanceState)
�AliasedClass)
�WriteOnlyCollection)
�_ColumnExpressionArgument)
�	_InfoType)
�
ColumnElement)
�OperatorType�_T)
�bound�_T_coT)r,�	covariant�_Oc
@
s.eZ
dZd
Z	dZ	dZ	dZ	dZ	eZdS)�LoaderCallableStatusr
rr��N)	�__name__�
__module__�__qualname__�PASSIVE_NO_RESULT�PASSIVE_CLASS_MISMATCH�ATTR_WAS_SET�
ATTR_EMPTY�NO_VALUE�	NEVER_SET�r<r<�>/usr/local/lib/python3.10/dist-packages/sqlalchemy/orm/base.pyr0As






r0c@
s�eZ
dZd
ZdZ	dZ	dZ	dZ	dZ	dZ		dZ
	d	Z	d
Z	dZ
	dZee	BeBeBeBZ	eeAZ	eeAZ	eeAZ	eeAZ	ee	AZ	eeBZd
S)�PassiveFlagz;Bitflag interface that passes options onto loader callablesr
rrr2��� �@��
iN)r3r4r5�__doc__�	NO_CHANGE�CALLABLES_OK�SQL_OK�RELATED_OBJECT_OK�INIT_OK�NON_PERSISTENT_OK�LOAD_AGAINST_COMMITTED�NO_AUTOFLUSH�NO_RAISE�DEFERRED_HISTORY_LOAD�INCLUDE_PENDING_MUTATIONS�PASSIVE_OFF�PASSIVE_RETURN_NO_VALUE�PASSIVE_NO_INITIALIZE�PASSIVE_NO_FETCH�PASSIVE_NO_FETCH_RELATED�PASSIVE_ONLY_PERSISTENT�
PASSIVE_MERGEr<r<r<r=r>psL










�





r>�_sa_class_manager�_sa_instance_statec
@
seZ
dZd
ZdZdZdZdS)�EventConstantsrrr1r2N)r3r4r5�EXT_CONTINUE�EXT_STOP�EXT_SKIP�NO_KEYr<r<r<r=rZ�s




rZc
@
s eZ
dZd
ZdZ	dZ	dZdS)�RelationshipDirectionz�enumeration which indicates the 'direction' of a
    :class:`_orm.RelationshipProperty`.

    :class:`.RelationshipDirection` is accessible from the
    :attr:`_orm.Relationship.direction` attribute of
    :class:`_orm.RelationshipProperty`.

    rrr1N)r3r4r5rE�	ONETOMANY�	MANYTOONE�
MANYTOMANYr<r<r<r=r_�s
	


r_c
@
�eZ
dZd
ZdS)�InspectionAttrExtensionTypezXSymbols indicating the type of extension that a
    :class:`.InspectionAttr` is part of.N)r3r4r5rEr<r<r<r=rd

s
rdc
@
rc)�NotExtension�
not_extensionN)r3r4r5�
NOT_EXTENSIONr<r<r<r=re
s

re�SET_DEFERRED_EXPIRED�DEFER_FOR_STATE�RAISE_FOR_STATE�_F.�_Self�
assertionsr�return�Callable[[_F], _F]c
stj
d�f
d	d
��
}
|
S)N�fnrk�selfrl�argsr�kwrnc
s0�D]}||
|j�
q||
g
|�
Ri|�
�

|
S�
N)
r3)rprqrrrs�	assertion�
rmr<r=�generate.
s


z_assertions.<locals>.generate)
rprkrqrlrrrrsrrnrl)r�	decorator)rmrwr<rvr=�_assertions+
s
ry�cls�Type[_O]�ClassManager[_O]c


C
�dSrtr<�
rzr<r<r=�manager_of_class:
�r�AliasedClass[Any]�Nonec


C
r}rtr<r~r<r<r=�opt_manager_of_class<
�
r��_ExternalEntityType[_O]�Optional[ClassManager[_O]]c


C
r}rtr<r~r<r<r=r�?
�c


C
r}rtr<r~r<r<r=r�D
��instance�InstanceState[_O]c


C
r}rtr<�
r�r<r<r=�instance_stateH
r�r��object�Dict[str, Any]c


C
r}rtr<r�r<r<r=�
instance_dictJ
r�r�c

C
s:z|jt
WSty
}

z
t�|d
|���|
�d}
~
w
w)Nz2Can't locate an instrumentation manager for class )�__dict__�DEFAULT_MANAGER_ATTR�KeyErrorr�UnmappedClassError)rz�ker<r<r=rP
s





����c

C
s|j�
t�
Srt)r��getr�r~r<r<r=r�X
s
r��strc

C
stt
|�
�
S)
z'Return a string describing an instance.)�	state_strr�r�r<r<r=�instance_str`
sr��state�InstanceState[Any]c

C
s$|d
urdSd|jj
t|���
fS)z=Return a string describing an instance via its InstanceState.Nr�z<%s at 0x%x>)�class_r3�id�obj�
r�r<r<r=r�f
s
r�c

C
s|d
urdSd|jj
f
S)zNReturn a string describing an instance's class via its
    InstanceState.
    Nr�z<%s>)r�r3r�r<r<r=�state_class_stro
s
r��	attributecC
�t|�
d
|
S�N�
.)
r�)r�r�r<r<r=�
attribute_strz
�
r�cC
r�r�)
r�)r�r�r<r<r=�state_attribute_str~
r�r��
Mapper[_T]c

C
s
t|�
j
S)
a�
Given an object, return the primary Mapper associated with the object
    instance.

    Raises :class:`sqlalchemy.orm.exc.UnmappedInstanceError`
    if no mapping is configured.

    This function is available via the inspection system as::

        inspect(instance).mapper

    Using the inspection system will raise
    :class:`sqlalchemy.exc.NoInspectionAvailable` if the instance is
    not part of a mapping.

    )�object_state�mapperr�r<r<r=�
object_mapper�
s
r��InstanceState[_T]c
C
st|�
}
|
d
ur
t
�|�
�
|
S)a�
Given an object, return the :class:`.InstanceState`
    associated with the object.

    Raises :class:`sqlalchemy.orm.exc.UnmappedInstanceError`
    if no mapping is configured.

    Equivalent functionality is available via the :func:`_sa.inspect`
    function as::

        inspect(instance)

    Using the inspection system will raise
    :class:`sqlalchemy.exc.NoInspectionAvailable` if the instance is
    not part of a mapping.

    N)�_inspect_mapped_objectr�UnmappedInstanceError)r�r�r<r<r=r��
s


r��Optional[InstanceState[_T]]c

	C
s*zt|�
WSt
jf
t
jy


YdSwrt)r�rr��NO_STATEr�r<r<r=r��
s




�r��class_or_mapper�Union[Mapper[_T], Type[_T]]c
C
s2t�
|d
�}
|
du
r
|
jSt|t�sJ�
t�|�
�
)NF)r�inspectr��
isinstance�typerr�)r��inspr<r<r=�_class_to_mapper�
s




r��entity�(Union[Type[_T], _InternalEntityType[_T]]�Optional[Mapper[_T]]c
C
st�
|d
�}
|
du
r
|
jSdS)z`Return the :class:`_orm.Mapper` for the given class or None if the
    class is not mapped.
    FN)rr�r��r�r�r<r<r=�_mapper_or_none�
s

r��boolc
C
s(t�
|d
�}
|
du
o|
jo|
jp|
jS)zlReturn True if the given object is a mapped class,
    :class:`_orm.Mapper`, or :class:`.AliasedClass`.
    FN)rr��is_clause_element�	is_mapper�is_aliased_classr�r<r<r=�_is_mapped_class�
s
�
�r�c
C
s t�
|d
�}
|
du
ot|
dd
�S)NFr�)rr��getattrr�r<r<r=�_is_aliased_class�
s

r��_EntityType[Any]�keyc
C
s�t�
|�
}|jr|}|j}n|jr|j}|}nt|d
�r#|jj}}n|}zt	||
�WSt
yA
}
z
t�d||
f�
|�d}~w
w)z�Return a class attribute given an entity and string name.

    May return :class:`.InstrumentedAttribute` or user-defined
    attribute.

    r�z Entity '%s' has no property '%s'N)
rr��
is_selectable�
cr�r��hasattrr�r�r��AttributeError�sa_exc�InvalidRequestError)r�r�r��description�errr<r<r=�_entity_descriptor�
s(














����r��
Mapper[_O]c


C
r}rtr<r�r<r<r=�
_state_mapperr�r�zmanager.mapperFr��	configure�Optional[Mapper[_O]]cC
sNzt|�
}|dus|j
sWdS|j}Wntjy


YdSw|
r%|��
|Srt)r��	is_mappedr�rr��_check_configure)r�r��
class_managerr�r<r<r=�_inspect_mapped_classs






�

r��arg�Union[Mapper[_O], Type[_O]]c
C
s*tj
|d
d�}
t|
�
r
|
St�d|���
�
)NF)
�raiseerrz%Mapper or mapped class expected, got )rr�rr��
ArgumentError)r�r�r<r<r=�_parse_mapper_arguments


r�cC
s<t||
d
�}|durt
|t�st�d|f
�
�
t�|�
�
|S)a�
Given a class, return the primary :class:`_orm.Mapper` associated
    with the key.

    Raises :exc:`.UnmappedClassError` if no mapping is configured
    on the given class, or :exc:`.ArgumentError` if a non-class
    object is passed.

    Equivalent functionality is available via the :func:`_sa.inspect`
    function as::

        inspect(some_mapped_class)

    Using the inspection system will raise
    :class:`sqlalchemy.exc.NoInspectionAvailable` if the class is not mapped.

    )
r�Nz Class object expected, got '%r'.)r�r�r�r�r�rr�)r�r�r�r<r<r=�class_mappers




�
r�c@
sbeZ
dZUd
ZdZded<dZ	dZ	dZ	dZ		dZ
	dZ	dZ	dZ
	dZ	ejZded<dS)	�InspectionAttraMA base class applied to all ORM objects and attributes that are
    related to things that can be returned by the :func:`_sa.inspect` function.

    The attributes defined here allow the usage of simple boolean
    checks to test basic facts about the object returned.

    While the boolean checks here are basically the same as using
    the Python isinstance() function, the flags here can be used without
    the need to import all of these classes, and also such that
    the SQLAlchemy class system can change while leaving the flags
    here intact for forwards-compatibility.

    r<zTuple[str, ...]�	__slots__Frd�extension_typeN)r3r4r5rEr��__annotations__r�r��is_instancer��	is_bundle�is_property�is_attribute�_is_internal_proxyr�rergr�r<r<r<r=r�:s.











r�c@
s$eZ
dZd
ZdZejddd��
ZdS)	�InspectionAttrInfoa
Adds the ``.info`` attribute to :class:`.InspectionAttr`.

    The rationale for :class:`.InspectionAttr` vs. :class:`.InspectionAttrInfo`
    is that the former is compatible as a mixin for classes that specify
    ``__slots__``; this is essentially an implementation artifact.

    r<rnr(c


C
siS)
a�
Info dictionary associated with the object, allowing user-defined
        data to be associated with this :class:`.InspectionAttr`.

        The dictionary is generated when first accessed.  Alternatively,
        it can be specified as a constructor argument to the
        :func:`.column_property`, :func:`_orm.relationship`, or
        :func:`.composite`
        functions.

        .. seealso::

            :attr:`.QueryableAttribute.info`

            :attr:`.SchemaItem.info`

        r<)
rqr<r<r=�info�szInspectionAttrInfo.infoN)rnr()r3r4r5rEr�r�ro_memoized_propertyr�r<r<r<r=r��s


r�c@
sJeZ
dZd
Zejr#ddd�Zddd�Z	
dddd�Z	
dddd�Z	d
Sd
S)�SQLORMOperationsr<r�r�rn�PropComparator[_T_co]c
C
r}rtr<)rqr�r<r<r=�of_type�r�zSQLORMOperations.of_type�criteria�_ColumnExpressionArgument[bool]�PropComparator[bool]c

G
r}rtr<)rqr�r<r<r=�and_�r�zSQLORMOperations.and_N�	criterion�)Optional[_ColumnExpressionArgument[bool]]�kwargsr�ColumnElement[bool]c
K
r}rtr<�rqr�r�r<r<r=�any��zSQLORMOperations.anyc
K
r}rtr<r�r<r<r=�has�r�zSQLORMOperations.has)r�r�rnr�)r�r�rnr�rt)r�r�r�rrnr�)
r3r4r5r��typingr
r�r�r�r�r<r<r<r=r��s


���r�c@
sReZ
dZd
ZdZejr'edd	d
��
Zeddd
��
Zeddd
��
Zddd
�ZdSdS)�
ORMDescriptorz`Represent any Python descriptor that provides a SQL expression
    construct at the class level.r<r�r�owner�
Literal[None]rn�ORMDescriptor[_T_co]c
C
r}rtr<�rqr�r�r<r<r=�__get__�r�zORMDescriptor.__get__�SQLCoreOperations[_T_co]c
C
r}rtr<r�r<r<r=r��r�r�r-c
C
r}rtr<r�r<r<r=r��r��<Union[ORMDescriptor[_T_co], SQLCoreOperations[_T_co], _T_co]c
C
r}rtr<r�r<r<r=r��r�N)r�rr�r�rnr�)r�r�r�rrnr��r�r�r�rrnr-)r�r�r�rrnr�)	r3r4r5rEr�r�r
r
r�r<r<r<r=r��s



�r�c
@
�eZ
dZd
ZdZdS)�_MappedAnnotationBasez�common class for Mapped and similar ORM container classes.

    these are classes that can appear on the left side of an ORM declarative
    mapping, containing a mapped class or in some cases a collection
    surrounding a mapped class.

    r<N�r3r4r5rEr�r<r<r<r=r
�s
r
c
@
r

)�SQLORMExpressionaCA type that may be used to indicate any ORM-level attribute or
    object that acts in place of one, in the context of SQL expression
    construction.

    :class:`.SQLORMExpression` extends from the Core
    :class:`.SQLColumnExpression` to add additional SQL methods that are ORM
    specific, such as :meth:`.PropComparator.of_type`, and is part of the bases
    for :class:`.InstrumentedAttribute`. It may be used in :pep:`484` typing to
    indicate arguments or return values that should behave as ORM-level
    attribute expressions.

    .. versionadded:: 2.0.0b4


    r<Nr
r<r<r<r=r
�sr
c@
sfeZ
dZd
ZdZejr1edd	d
��
Zedd
d
��
Zddd
�Ze	ddd��
Z
d dd�Zd!dd�ZdSdS)"�MappedajRepresent an ORM mapped attribute on a mapped class.

    This class represents the complete descriptor interface for any class
    attribute that will have been :term:`instrumented` by the ORM
    :class:`_orm.Mapper` class.   Provides appropriate information to type
    checkers such as pylance and mypy so that ORM-mapped attributes
    are correctly typed.

    The most prominent use of :class:`_orm.Mapped` is in
    the :ref:`Declarative Mapping <orm_explicit_declarative_base>` form
    of :class:`_orm.Mapper` configuration, where used explicitly it drives
    the configuration of ORM attributes such as :func:`_orm.mapped_class`
    and :func:`_orm.relationship`.

    .. seealso::

        :ref:`orm_explicit_declarative_base`

        :ref:`orm_declarative_table`

    .. tip::

        The :class:`_orm.Mapped` class represents attributes that are handled
        directly by the :class:`_orm.Mapper` class. It does not include other
        Python descriptor classes that are provided as extensions, including
        :ref:`hybrids_toplevel` and the :ref:`associationproxy_toplevel`.
        While these systems still make use of ORM-specific superclasses
        and structures, they are not :term:`instrumented` by the
        :class:`_orm.Mapper` and instead provide their own functionality
        when they are accessed on a class.

    .. versionadded:: 1.4


    r<r�r�r�rrn�InstrumentedAttribute[_T_co]c
C
r}rtr<r�r<r<r=r�*r�zMapped.__get__r�r-c
C
r}rtr<r�r<r<r=r�/r��Optional[object]�*Union[InstrumentedAttribute[_T_co], _T_co]c
C
r}rtr<r�r<r<r=r�2r��arg1�
Mapped[_T_co]c
C
r}rtr<)rzr	
r<r<r=�_empty_constructor6r�zMapped._empty_constructor�value�&Union[SQLCoreOperations[_T_co], _T_co]c
C
r}rtr<�rqr�r
r<r<r=�__set__9r�zMapped.__set__c
C
r}rtr<)rqr�r<r<r=�
__delete__=r�zMapped.__delete__N�r�r�r�rrnr
r
)r�r
r�rrnr
)r	
rrnr

)r�rr
r

rnr�)r�rrnr�)
r3r4r5rEr�r�r
r
r��classmethodr
r
r
r<r<r<r=r
�s$




�r
c
@
r

)�_MappedAttributezVMixin for attributes which should be replaced by mapper-assigned
    attributes.

    r<Nr
r<r<r<r=r
@s
r
c@
s,eZ
dZd
ZdZdd	d
�ZeZddd�Zd
S)�_DeclarativeMappedz�Mixin for :class:`.MapperProperty` subclasses that allows them to
    be compatible with ORM-annotated declarative mappings.

    r<�opr*�otherrr�rnc
O
�tSrt�
�NotImplemented�rqr
r
r�r<r<r=�operateWr�z_DeclarativeMapped.operatec
K
r
rtr
r
r<r<r=�reverse_operate\r�z"_DeclarativeMapped.reverse_operateN)r
r*r
rr�rrnr)r3r4r5rEr�r
�__sa_operate__r
r<r<r<r=r
Is

r
c@
�LeZ
dZd
ZdZer$edd	d
��
Zedd
d
��
Zddd
�Zddd�ZdSdS)�
DynamicMappeda�Represent the ORM mapped attribute type for a "dynamic" relationship.

    The :class:`_orm.DynamicMapped` type annotation may be used in an
    :ref:`Annotated Declarative Table <orm_declarative_mapped_column>` mapping
    to indicate that the ``lazy="dynamic"`` loader strategy should be used
    for a particular :func:`_orm.relationship`.

    .. legacy::  The "dynamic" lazy loader strategy is the legacy form of what
       is now the "write_only" strategy described in the section
       :ref:`write_only_relationship`.

    E.g.::

        class User(Base):
            __tablename__ = "user"
            id: Mapped[int] = mapped_column(primary_key=True)
            addresses: DynamicMapped[Address] = relationship(
                cascade="all,delete-orphan"
            )

    See the section :ref:`dynamic_relationship` for background.

    .. versionadded:: 2.0

    .. seealso::

        :ref:`dynamic_relationship` - complete background

        :class:`.WriteOnlyMapped` - fully 2.0 style version

    r<r�r�r�rrnr
c
C
r}rtr<r�r<r<r=r��r�zDynamicMapped.__get__r��AppenderQuery[_T_co]c
C
r}rtr<r�r<r<r=r��r�r
�9Union[InstrumentedAttribute[_T_co], AppenderQuery[_T_co]]c
C
r}rtr<r�r<r<r=r��r�r
�typing.Collection[_T_co]c
C
r}rtr<r
r<r<r=r
�r�zDynamicMapped.__set__Nr
)r�r�r�rrnr 
)r�r
r�rrnr!
�r�rr
r"
rnr��	r3r4r5rEr�r
r
r�r
r<r<r<r=r
bs
 


�r
c@
r
)�WriteOnlyMappedadRepresent the ORM mapped attribute type for a "write only" relationship.

    The :class:`_orm.WriteOnlyMapped` type annotation may be used in an
    :ref:`Annotated Declarative Table <orm_declarative_mapped_column>` mapping
    to indicate that the ``lazy="write_only"`` loader strategy should be used
    for a particular :func:`_orm.relationship`.

    E.g.::

        class User(Base):
            __tablename__ = "user"
            id: Mapped[int] = mapped_column(primary_key=True)
            addresses: WriteOnlyMapped[Address] = relationship(
                cascade="all,delete-orphan"
            )

    See the section :ref:`write_only_relationship` for background.

    .. versionadded:: 2.0

    .. seealso::

        :ref:`write_only_relationship` - complete background

        :class:`.DynamicMapped` - includes legacy :class:`_orm.Query` support

    r<r�r�r�rrnr
c
C
r}rtr<r�r<r<r=r��r�zWriteOnlyMapped.__get__r��WriteOnlyCollection[_T_co]c
C
r}rtr<r�r<r<r=r��r�r
�?Union[InstrumentedAttribute[_T_co], WriteOnlyCollection[_T_co]]c
C
r}rtr<r�r<r<r=r��r�r
r"
c
C
r}rtr<r
r<r<r=r
�r�zWriteOnlyMapped.__set__Nr
)r�r�r�rrnr&
)r�r
r�rrnr'
r#
r$
r<r<r<r=r%
�s



�r%
)rmrrnro)rzr{rnr|)rzr�rnr�)rzr�rnr�)r�r/rnr�)r�r�rnr�)r�r�rnr�)r�r�rnr�)r�r�r�r�rnr�)r�r�r�r�rnr�)r�r+rnr�)r�r+rnr�)r�r+rnr�)r�r�rnr�)r�r�rnr�)r�rrnr�)r�r�r�r�rnr)r�r�rnr�)
F)r�r{r�r�rnr�)r�r�rnr�)
T)r�r{r�r�rnr�)�rE�
__future__r�enumr�operatorr�rrrrrr	r
rrr
rr�r�_typingrr�rr�sqlr�sql.elementsrrr�util.langhelpersr�util.typingrrrr�
attributesr�dynamicr �instrumentationr!�
interfacesr"r�r#r�r$r%�	writeonlyr&�sql._typingr'r(r)�
sql.operatorsr*r+r-r�r/r0�tupler6r7r8r9r:r;r>�__members__�valuesrFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWr��DEFAULT_STATE_ATTRrZr[r\r]r^r_r`rarbrdre�	frozenset�
_never_set�	_none_set�_none_only_set�symbol�_SET_DEFERRED_EXPIRED�_DEFER_FOR_STATE�_RAISE_FOR_STATErkrlryrr�r�r��
attrgetterr�r�r�r�r�r�r��	_inspectsr�r�r�r�r�r�r��dottedgetterr�r�r�r�r�r�r�r
r
�DDLConstraintColumnRoler
r
r
r
r%
r<r<r<r=�<module>
s&








































*�




^�



















#
















	











�
L 

�




�D	8