o

���g��
@
s�dZd
dl
mZ
d
dlZd
dlZd
dlZd
dlmZ
d
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
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlZddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlmZ
ddlm Z 
ddlm!Z!
ddlm"Z"
ddlm#Z#
dd lm$Z$
dd!l%m&Z&
dd"l%m'Z'
dd#l%m(Z(
dd$l%m)Z)
dd%l*m+Z+
dd&l*m,Z,
dd'l*m-Z-
dd(l*m.Z.
dd)l*m/Z/
dd*l*m0Z0
dd+l*m1Z1
dd,l2m3Z3
dd-l2m4Z4
dd-l2m4Z5
dd.l6m7Z7
dd/l8m9Z9
dd0l:m;Z;
dd1l<m=Z=
d2d3lm>Z>
d2d4lm?Z?
d2d5lm@Z@
d2d6lAmBZB
d2d7lCmDZD
d2d8lEmFZF
d2d9lGmHZH
d2d:lImJZJ
d2d;l@mKZK
d2d<l@mLZL
d2d=l@mZM
d2d>l@mNZN
d2d?lOmPZP
d2d@lOmQZQ
d2dAlOmRZR
d2dBlOmSZS
d2dClOmTZT
d2dDlOmUZU
d2dElOmVZV
d2dFlOmWZW
d2dGlOmXZX
d2dHlOmYZY
e�
r�ddIlZm[Z[
ddJlZm\Z\
ddKl*m]Z]
ddLlm^Z^
ddMlm_Z_
dd1l<m=Z=
d2dNl`maZa
d2dOlbmcZc
edPedQ�ZdedRedQ�ZeeedSfZfe	edSfZgedTee(ede)edeFedffZhd�dYdZ�ZiGd[d\�d\ej�ZkGd]d^�d^eke?jle7e�ZmeMjne9e;e3e4e!e"ee#e f	d_�
Gd`da�daem��
ZoGdbdc�dcem�Zp	dd�d�didj�ZqGdkdl�dl�ZrGdmdn�dnereed�ZsGdodp�dpejteder�ZuGdqdr�dreued�Zvd�dtdu�Zwd�dxdy�ZxGdzd{�d{eod|�ZyGd}d~�d~e?jle=eemd|�Zzd�d�d��Z{Gd�d��d�e?jle=e�Z|d�d�d��Z}dde~d�dde.epd��d�d�d��ZGd�d��d��Z�e�Z�e�s�e�Z\d�d�d��Z�e?��epezem�d�d�d���
Z�dS)�z1Public API functions and helpers for declarative.�)
�annotationsN)
�Any)
�Callable)
�ClassVar)
�Dict)
�	FrozenSet)
�Generic)
�Iterable)
�Iterator)
�Mapping)
�Optional)
�overload)
�Set)
�Tuple)
�Type)
�
TYPE_CHECKING)
�TypeVar)
�Union�
)
�
attributes)
�clsregistry)
�instrumentation)
�
interfaces)
�	mapperlib)
�	composite)
�deferred)
�
mapped_column)
�relationship)
�synonym)
�InstrumentedAttribute)
�_inspect_mapped_class)
�_is_mapped_class)
�Mapped)
�
ORMDescriptor�
�_add_attribute)
�_as_declarative)
�_ClassScanMapperConfig)
�_declarative_constructor)
�_DeferredMapperConfig)
�_del_attribute�
�_mapper)
�	Composite)
�Synonym)
�Mapper)
�MappedColumn)
�RelationshipProperty)
�
InstanceState�)
�exc)
�
inspection)
�util)
�sqltypes)
�_NoArg)
�SQLCoreOperations)
�MetaData)
�
FromClause)
�hybridmethod)
�hybridproperty)
�typing)
�warn_deprecated)
�CallableReference�
�de_optionalize_union_types)
�flatten_newtype)
�
is_generic)
�
is_literal)
�
is_newtype)
�	is_pep695)
�Literal)
�
LITERAL_TYPES)
�Self)
�_O)
�
_RegistryType)
�_DataclassArguments)
�ClassManager)
�MapperProperty)
�_TypeEngineArgument)
�_MatchedOnType�_T)
�bound�_TTz_TypeEngineArgument[Any].�cls�Type[_O]�return�boolc
C
s.|jd
d�D]
}
t
|
dd�du
r
dSqdS)aK
Given a class, return True if any of the classes it inherits from has a
    mapped table, otherwise return False.

    This is used in declarative mixins to build attributes that behave
    differently for the base class vs. a subclass in an inheritance
    hierarchy.

    .. seealso::

        :ref:`decl_mixin_inheritance`

    rN�	__table__TF)�__mro__�getattr)rU�class_�r]�B/usr/local/lib/python3.10/dist-packages/sqlalchemy/orm/decl_api.py�has_inherited_tablens



�r_c@
s eZ
dZddd�Zd
d	d
�ZdS)�_DynamicAttributesType�key�str�valuerrW�NonecC
s,d
|jvr
t
||
|�
dSt�||
|�
dS�N�
__mapper__)�__dict__r%�type�__setattr__)rUrarcr]r]r^ri�s


z"_DynamicAttributesType.__setattr__cC
s(d
|jvrt
||
�
dSt�||
�
dSre)rgr*rh�__delattr__�rUrar]r]r^rj�s


z"_DynamicAttributesType.__delattr__N)rarbrcrrWrd)rarbrWrd)�__name__�
__module__�__qualname__rirjr]r]r]r^r`�s

r`c
@
�eZ
dZd
ZdS)�DeclarativeAttributeInterceptz�Metaclass that may be used in conjunction with the
    :class:`_orm.DeclarativeBase` class to support addition of class
    attributes dynamically.

    N�rlrmrn�__doc__r]r]r]r^rp�srp�
�field_specifiersc
@
ro)�DCTransformDeclarativez-metaclass that includes @dataclass_transformsNrqr]r]r]r^ru�sruc@
s(eZ
dZUd
ed<ded<ddd
�ZdS)�DeclarativeMetar:�metadata�RegistryType�registry�	classnamer�bases�dict_�kwrWrdcK
sn|j}t
|d
d�}|dur |�dd�}t|t�st�d�
�
||_|j�dd�s-t|||�
t	�
||
||�
dS)N�_sa_registryryziDeclarative base class has no 'registry' attribute, or registry is not a sqlalchemy.orm.registry() object�__abstract__F)rgr[�get�
isinstanceryr4�InvalidRequestErrorr~r&rh�__init__)rUrzr{r|r}�regr]r]r^r��s





�

zDeclarativeMeta.__init__N)
rzrr{rr|rr}rrWrd)rlrmrn�__annotations__r�r]r]r]r^rv�s


rvF�namerb�
map_column�,Callable[[Callable[..., Any]], Synonym[Any]]c
sd��
fdd�}|S)	aDecorator that produces an :func:`_orm.synonym`
    attribute in conjunction with a Python descriptor.

    The function being decorated is passed to :func:`_orm.synonym` as the
    :paramref:`.orm.synonym.descriptor` parameter::

        class MyClass(Base):
            __tablename__ = "my_table"

            id = Column(Integer, primary_key=True)
            _job_status = Column("job_status", String(50))

            @synonym_for("job_status")
            @property
            def job_status(self):
                return "Status: %s" % self._job_status

    The :ref:`hybrid properties <mapper_hybrids>` feature of SQLAlchemy
    is typically preferred instead of synonyms, which is a more legacy
    feature.

    .. seealso::

        :ref:`synonyms` - Overview of synonyms

        :func:`_orm.synonym` - the mapper-level function

        :ref:`mapper_hybrids` - The Hybrid Attribute extension provides an
        updated approach to augmenting attribute behavior more flexibly than
        can be achieved with synonyms.

    �fn�Callable[..., Any]rW�Synonym[Any]c


st�
�|d
�S)N)r��
descriptor)
�_orm_synonym)
r��r�r�r]r^�decorate��
zsynonym_for.<locals>.decorateN)r�r�rWr�r])r�r�r�r]r�r^�synonym_for�s$r�c@
s0eZ
dZ	
	
dddd�Zddd�Zddd�ZdS)�_declared_attr_commonFr�r��	cascadingrX�quietcC
s.t|
t
�r|
j}
|
|_||_||_|
j|_dS�
N)r��classmethod�__func__�fget�
_cascading�_quietrr)�selfr�r�r�r]r]r^r��s





z_declared_attr_common.__init__rW�Optional[Type[Any]]c

C
st�
|j�
�d
�
S)NrW)r6�get_annotationsr�r��
r�r]r]r^�_collect_return_annotation

�
z0_declared_attr_common._collect_return_annotation�instance�Optional[object]�ownerrcC
s�|}t�
|�
}|dur$t�d
|jj�st�d|jj|jf�

|�|�
S|jr,|�|�
S|�	�}|du
s6J�
|j
}||vrA||S|�|�
||<}|S)Nz^__.+__$zEUnmanaged access of declarative attribute %s from non-mapped class %s)r�opt_manager_of_class�re�matchr�rlr6�warn�	is_mapped�declarative_scan�declared_attr_reg)r�r�r�rU�managerr�r��objr]r]r^�__get__

s&





��




z_declared_attr_common.__get__N)FF)r�r�r�rXr�rX)rWr�)r�r�r�rrWr)rlrmrnr�r�r�r]r]r]r^r��s
�
r�c@
sLeZ
dZejr$	
dddd�Zddd�Zddd�Zddd�Zd dd�Z	dSdS)!�_declared_directiveFr��Callable[..., _T]r�rXc
C
�dSr�r]�r�r�r�r]r]r^r�:
�z_declared_directive.__init__r�r�r�rrWrRc
C
r�r�r]�r�r�r�r]r]r^r�@
�z_declared_directive.__get__rcrdc
C
r�r�r]�r�r�rcr]r]r^�__set__B
r�z_declared_directive.__set__c
C
r�r�r]�r�r�r]r]r^�
__delete__D
r�z_declared_directive.__delete__�Callable[..., _TT]�_declared_directive[_TT]c
C
r�r�r]�r�r�r]r]r^�__call__F
�z_declared_directive.__call__N�
F)r�r�r�rX)r�r�r�rrWrR�r�rrcrrWrd�r�rrWrd)r�r�rWr�)
rlrmrnr>rr�r�r�r�r�r]r]r]r^r�5
s�


�r�c@
s�eZ
dZd
Zejr-	d&d'dd�Zd(dd�Zd)dd�Ze	d*dd��
Z
e	d+dd��
Z
d,dd�Z
ed-dd��
Ze
d.d!d"��
Ze
d/d#d$��
Zd%S)0�
declared_attraMark a class-level method as representing the definition of
    a mapped property or Declarative directive.

    :class:`_orm.declared_attr` is typically applied as a decorator to a class
    level method, turning the attribute into a scalar-like property that can be
    invoked from the uninstantiated class. The Declarative mapping process
    looks for these :class:`_orm.declared_attr` callables as it scans classes,
    and assumes any attribute marked with :class:`_orm.declared_attr` will be a
    callable that will produce an object specific to the Declarative mapping or
    table configuration.

    :class:`_orm.declared_attr` is usually applicable to
    :ref:`mixins <orm_mixins_toplevel>`, to define relationships that are to be
    applied to different implementors of the class. It may also be used to
    define dynamically generated column expressions and other Declarative
    attributes.

    Example::

        class ProvidesUserMixin:
            "A mixin that adds a 'user' relationship to classes."

            user_id: Mapped[int] = mapped_column(ForeignKey("user_table.id"))

            @declared_attr
            def user(cls) -> Mapped["User"]:
                return relationship("User")

    When used with Declarative directives such as ``__tablename__``, the
    :meth:`_orm.declared_attr.directive` modifier may be used which indicates
    to :pep:`484` typing tools that the given method is not dealing with
    :class:`_orm.Mapped` attributes::

        class CreateTableName:
            @declared_attr.directive
            def __tablename__(cls) -> str:
                return cls.__name__.lower()

    :class:`_orm.declared_attr` can also be applied directly to mapped
    classes, to allow for attributes that dynamically configure themselves
    on subclasses when using mapped inheritance schemes.   Below
    illustrates :class:`_orm.declared_attr` to create a dynamic scheme
    for generating the :paramref:`_orm.Mapper.polymorphic_identity` parameter
    for subclasses::

        class Employee(Base):
            __tablename__ = "employee"

            id: Mapped[int] = mapped_column(primary_key=True)
            type: Mapped[str] = mapped_column(String(50))

            @declared_attr.directive
            def __mapper_args__(cls) -> Dict[str, Any]:
                if cls.__name__ == "Employee":
                    return {
                        "polymorphic_on": cls.type,
                        "polymorphic_identity": "Employee",
                    }
                else:
                    return {"polymorphic_identity": cls.__name__}


        class Engineer(Employee):
            pass

    :class:`_orm.declared_attr` supports decorating functions that are
    explicitly decorated with ``@classmethod``. This is never necessary from a
    runtime perspective, however may be needed in order to support :pep:`484`
    typing tools that don't otherwise recognize the decorated function as
    having class-level behaviors for the ``cls`` parameter::

        class SomethingMixin:
            x: Mapped[int]
            y: Mapped[int]

            @declared_attr
            @classmethod
            def x_plus_y(cls) -> Mapped[int]:
                return column_property(cls.x + cls.y)

    .. versionadded:: 2.0 - :class:`_orm.declared_attr` can accommodate a
       function decorated with ``@classmethod`` to help with :pep:`484`
       integration where needed.


    .. seealso::

        :ref:`orm_mixins_toplevel` - Declarative Mixin documentation with
        background on use patterns for :class:`_orm.declared_attr`.

    Fr��_DeclaredAttrDecorated[_T]r�rXc
C
r�r�r]r�r]r]r^r��
r�zdeclared_attr.__init__r�rrcrWrdc
C
r�r�r]r�r]r]r^r��
r�zdeclared_attr.__set__c
C
r�r�r]r�r]r]r^r��
r�zdeclared_attr.__delete__r��InstrumentedAttribute[_T]c
C
r�r�r]r�r]r]r^r��
�zdeclared_attr.__get__�objectrRc
C
r�r�r]r�r]r]r^r��
s
r��$Union[InstrumentedAttribute[_T], _T]c
C
r�r�r]r�r]r]r^r��
r�r}�_stateful_declared_attr[_T]c
K
std
i|
�
�
S�Nr])
�_stateful_declared_attr�rUr}r]r]r^�	_stateful�
szdeclared_attr._stateful�_declared_directive[Any]c


C
stSr�)
r��
rUr]r]r^�	directive�
r�zdeclared_attr.directivec

C
s|jd
d�
S)NT)
r�)
r�r�r]r]r^r��
szdeclared_attr.cascadingNr�)r�r�r�rXr�r�)r�rdr�rrWr�)r�r�r�rrWrR)r�r�r�rrWr��r}rrWr�)rWr�)rWr�)rlrmrnrrr>rr�r�r�r
r�r<r�r=r�r�r]r]r]r^r�K
s$
\�







r�c@
s8eZ
dZUd
ed<ddd�Zeddd	��
Zdd
d�ZdS)r�zDict[str, Any]r}rc
K
s
|
|_dSr�)
r}�r�r}r]r]r^r��
s

z _stateful_declared_attr.__init__rWr�c
K
s"|j�
�}|�|
�

td
i|�
�
Sr�)r}�copy�updater�)r�r}�new_kwr]r]r^r��
s



z!_stateful_declared_attr._statefulr�r��declared_attr[_T]cC
st|
f
i|j
�
�
Sr�)r�r}r�r]r]r^r��
r�z _stateful_declared_attr.__call__N�r}rr�)r�r�rWr�)rlrmrnr�r�r<r�r�r]r]r]r^r��
s



r��Type[_T]c


C
�|S)
a.Mark a class as providing the feature of "declarative mixin".

    E.g.::

        from sqlalchemy.orm import declared_attr
        from sqlalchemy.orm import declarative_mixin


        @declarative_mixin
        class MyMixin:

            @declared_attr
            def __tablename__(cls):
                return cls.__name__.lower()

            __table_args__ = {"mysql_engine": "InnoDB"}
            __mapper_args__ = {"always_refresh": True}

            id = Column(Integer, primary_key=True)


        class MyModel(MyMixin, Base):
            name = Column(String(1000))

    The :func:`_orm.declarative_mixin` decorator currently does not modify
    the given class in any way; it's current purpose is strictly to assist
    the :ref:`Mypy plugin <mypy_toplevel>` in being able to identify
    SQLAlchemy declarative mixin classes when no other context is present.

    .. versionadded:: 1.4.6

    .. seealso::

        :ref:`orm_mixins_toplevel`

        :ref:`mypy_declarative_mixins` - in the
        :ref:`Mypy plugin documentation <mypy_toplevel>`

    r]r�r]r]r^�declarative_mixin�
s)r��	Type[Any]rdc
C
s�d
|jvr|jd
}
nd}
d|jvr|jd}nd}|j�
dd�}|du
r9t|t�s/t�d�
�
|du
r8t�d�
�
n	t|
|d�}||_||_d
|jv
rO|jj|_t|dt	j
�t	j
ur`|jj|_
dSdS)Nrw�type_annotation_mapryzfDeclarative base class has a 'registry' attribute that is not an instance of sqlalchemy.orm.registry()z�Declarative base class has both a 'registry' attribute and a type_annotation_map entry.  Per-base type_annotation_maps are not supported.  Please apply the type_annotation_map to this registry directly.)rwr�r�)rgr�r�ryr4r�r~rwr[r�r��constructor)rUrwr�r�r]r]r^�_setup_declarative_bases6









�

��	
�



�r�c
sDeZ
dZd
Zejejejejejejejejfd�f
dd�
Z�ZS)�MappedAsDataclassa
Mixin class to indicate when mapping this class, also convert it to be
    a dataclass.

    .. seealso::

        :ref:`orm_declarative_native_dataclasses` - complete background
        on SQLAlchemy native dataclass mapping

    .. versionadded:: 2.0

    �init�Union[_NoArg, bool]�repr�eq�order�unsafe_hash�
match_args�kw_only�dataclass_callable�'Union[_NoArg, Callable[..., Type[Any]]]r}rrWrdc	
	
s�|
|||||||d
�}
t|d�r'|j
�t���

�f
dd�|
��D�
|_
}n|
|_
}t�jdi|	�
�

t|�
sGt�|�
}t�	|||�
dSdS)N�r�r�r�r�r�r�r�r��_sa_apply_dc_transformsc

s.i|]\}
}|
|tj
ur��|
tj
�n
|�qSr])r8�NO_ARGr�)�.0�
k�
v�
�currentr]r^�
<dictcomp>es��z7MappedAsDataclass.__init_subclass__.<locals>.<dictcomp>r])
�hasattrr�r'�_assert_dc_arguments�items�super�__init_subclass__r!�(_update_annotations_for_non_mapped_class�_apply_dataclasses_to_any_class)
rUr�r�r�r�r�r�r�r�r}�apply_dc_transforms�current_transforms�new_anno�
�	__class__r�r^r�Es6






�




��
��
��z#MappedAsDataclass.__init_subclass__)r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r}rrWrd)rlrmrnrrr8r�r��
__classcell__r]r]r�r^r�8s






�r�)
�	metaclassc
s�eZ
dZUd
ZejrDddd�Zddd�Zd	ed
<d	ed<	ded
<	ded<ded<	ded<	ded<	ded<	ded<	d dd�Z	d!�f
dd�Z
�ZS)"�DeclarativeBasea�Base class used for declarative class definitions.

    The :class:`_orm.DeclarativeBase` allows for the creation of new
    declarative bases in such a way that is compatible with type checkers::


        from sqlalchemy.orm import DeclarativeBase


        class Base(DeclarativeBase):
            pass

    The above ``Base`` class is now usable as the base for new declarative
    mappings.  The superclass makes use of the ``__init_subclass__()``
    method to set up new classes and metaclasses aren't used.

    When first used, the :class:`_orm.DeclarativeBase` class instantiates a new
    :class:`_orm.registry` to be used with the base, assuming one was not
    provided explicitly. The :class:`_orm.DeclarativeBase` class supports
    class-level attributes which act as parameters for the construction of this
    registry; such as to indicate a specific :class:`_schema.MetaData`
    collection as well as a specific value for
    :paramref:`_orm.registry.type_annotation_map`::

        from typing_extensions import Annotated

        from sqlalchemy import BigInteger
        from sqlalchemy import MetaData
        from sqlalchemy import String
        from sqlalchemy.orm import DeclarativeBase

        bigint = Annotated[int, "bigint"]
        my_metadata = MetaData()


        class Base(DeclarativeBase):
            metadata = my_metadata
            type_annotation_map = {
                str: String().with_variant(String(255), "mysql", "mariadb"),
                bigint: BigInteger(),
            }

    Class-level attributes which may be specified include:

    :param metadata: optional :class:`_schema.MetaData` collection.
     If a :class:`_orm.registry` is constructed automatically, this
     :class:`_schema.MetaData` collection will be used to construct it.
     Otherwise, the local :class:`_schema.MetaData` collection will supercede
     that used by an existing :class:`_orm.registry` passed using the
     :paramref:`_orm.DeclarativeBase.registry` parameter.
    :param type_annotation_map: optional type annotation map that will be
     passed to the :class:`_orm.registry` as
     :paramref:`_orm.registry.type_annotation_map`.
    :param registry: supply a pre-existing :class:`_orm.registry` directly.

    .. versionadded:: 2.0  Added :class:`.DeclarativeBase`, so that declarative
       base classes may be constructed in such a way that is also recognized
       by :pep:`484` type checkers.   As a result, :class:`.DeclarativeBase`
       and other subclassing-oriented APIs should be seen as
       superseding previous "class returned by a function" APIs, namely
       :func:`_orm.declarative_base` and :meth:`_orm.registry.generate_base`,
       where the base class returned cannot be recognized by type checkers
       without using plugins.

    **__init__ behavior**

    In a plain Python class, the base-most ``__init__()`` method in the class
    hierarchy is ``object.__init__()``, which accepts no arguments. However,
    when the :class:`_orm.DeclarativeBase` subclass is first declared, the
    class is given an ``__init__()`` method that links to the
    :paramref:`_orm.registry.constructor` constructor function, if no
    ``__init__()`` method is already present; this is the usual declarative
    constructor that will assign keyword arguments as attributes on the
    instance, assuming those attributes are established at the class level
    (i.e. are mapped, or are linked to a descriptor). This constructor is
    **never accessed by a mapped class without being called explicitly via
    super()**, as mapped classes are themselves given an ``__init__()`` method
    directly which calls :paramref:`_orm.registry.constructor`, so in the
    default case works independently of what the base-most ``__init__()``
    method does.

    .. versionchanged:: 2.0.1  :class:`_orm.DeclarativeBase` has a default
       constructor that links to :paramref:`_orm.registry.constructor` by
       default, so that calls to ``super().__init__()`` can access this
       constructor. Previously, due to an implementation mistake, this default
       constructor was missing, and calling ``super().__init__()`` would invoke
       ``object.__init__()``.

    The :class:`_orm.DeclarativeBase` subclass may also declare an explicit
    ``__init__()`` method which will replace the use of the
    :paramref:`_orm.registry.constructor` function at this level::

        class Base(DeclarativeBase):
            def __init__(self, id=None):
                self.id = id

    Mapped classes still will not invoke this constructor implicitly; it
    remains only accessible by calling ``super().__init__()``::

        class MyClass(Base):
            def __init__(self, id=None, name=None):
                self.name = name
                super().__init__(id=id)

    Note that this is a different behavior from what functions like the legacy
    :func:`_orm.declarative_base` would do; the base created by those functions
    would always install :paramref:`_orm.registry.constructor` for
    ``__init__()``.


    rW�Mapper[Self]c


C
r�r�r]r�r]r]r^�_sa_inspect_type�r�z DeclarativeBase._sa_inspect_type�InstanceState[Self]c


C
r�r�r]r�r]r]r^�_sa_inspect_instance�r�z$DeclarativeBase._sa_inspect_instance�ClassVar[_RegistryType]r~ry�ClassVar[MetaData]rwz
ClassVar[str]rl�ClassVar[Mapper[Any]]rfzClassVar[FromClause]rYr�
__tablename__�__mapper_args__�__table_args__r}c

K
r�r�r]r�r]r]r^r�Cr�zDeclarativeBase.__init__rdc

�Dt|j
vrt|t�
t|�

nt|j||j�
t�jd
i|
�
�

dSr�)	r��	__bases__�_check_not_declarativer�r&r~rgr�r�r�r�r]r^r�E�







z!DeclarativeBase.__init_subclass__�rWr
�rWr
r��r}rrWrd)rlrmrnrrr>rr

r
r�r�r�r�r]r]r�r^r�ys.
p



	




	

r��basecC
sR|j}d
|vrt
|d
�
st|d
d�rt|�dd�t�r't�d|
j�d��
�
dS)NrYr�r
zCannot use zR directly as a declarative base class. Create a Base by creating a subclass of it.)	rg�callabler�r�r�rbr4r�rl)rUr
�cls_dictr]r]r^r
Ns

���
��r
c
s�eZ
dZUd
Zded<ded<	ded<	ded<	d	ed
<	ejr@dd
d�Zddd�Zded<	ded<	ded<	ddd�Z	d�f
dd�Z
�ZS) �DeclarativeBaseNoMetaz�Same as :class:`_orm.DeclarativeBase`, but does not use a metaclass
    to intercept new attributes.

    The :class:`_orm.DeclarativeBaseNoMeta` base may be used when use of
    custom metaclasses is desirable.

    .. versionadded:: 2.0


    r
r~ryr
rwr
rf�Optional[FromClause]rYrWr
c


C
r�r�r]r�r]r]r^r

�r�z&DeclarativeBaseNoMeta._sa_inspect_typer
c


C
r�r�r]r�r]r]r^r
�r�z*DeclarativeBaseNoMeta._sa_inspect_instancerr
r
r	
r}c

K
r�r�r]r�r]r]r^r��r�zDeclarativeBaseNoMeta.__init__rdc

r

r�)	r
r
r
r�r&r~rgr�r�r�r�r]r^r��r

z'DeclarativeBaseNoMeta.__init_subclass__r
r
r�r
)rlrmrnrrr�r>rr

r
r�r�r�r]r]r�r^r
]s,









	

r
�targetra�attr�MapperProperty[Any]cC
st||
|�
d
S)a'
Add a new mapped attribute to an ORM mapped class.

    E.g.::

        add_mapped_attribute(User, "addresses", relationship(Address))

    This may be used for ORM mappings that aren't using a declarative
    metaclass that intercepts attribute set operations.

    .. versionadded:: 2.0


    Nr$)r
rar
r]r]r^�add_mapped_attribute�sr
�Base�rw�mapperrUr��class_registryr�r�r�rw�Optional[MetaData]r
�$Optional[Callable[..., Mapper[Any]]]r
�&Optional[clsregistry._ClsRegistryType]r�� Optional[_TypeAnnotationMapType]r��Callable[..., None]r�rcC
st||||d
�j
|
|||d�S)aConstruct a base class for declarative class definitions.

    The new base class will be given a metaclass that produces
    appropriate :class:`~sqlalchemy.schema.Table` objects and makes
    the appropriate :class:`_orm.Mapper` calls based on the
    information provided declaratively in the class and any subclasses
    of the class.

    .. versionchanged:: 2.0 Note that the :func:`_orm.declarative_base`
       function is superseded by the new :class:`_orm.DeclarativeBase` class,
       which generates a new "base" class using subclassing, rather than
       return value of a function.  This allows an approach that is compatible
       with :pep:`484` typing tools.

    The :func:`_orm.declarative_base` function is a shorthand version
    of using the :meth:`_orm.registry.generate_base`
    method.  That is, the following::

        from sqlalchemy.orm import declarative_base

        Base = declarative_base()

    Is equivalent to::

        from sqlalchemy.orm import registry

        mapper_registry = registry()
        Base = mapper_registry.generate_base()

    See the docstring for :class:`_orm.registry`
    and :meth:`_orm.registry.generate_base`
    for more details.

    .. versionchanged:: 1.4  The :func:`_orm.declarative_base`
       function is now a specialization of the more generic
       :class:`_orm.registry` class.  The function also moves to the
       ``sqlalchemy.orm`` package from the ``declarative.ext`` package.


    :param metadata:
      An optional :class:`~sqlalchemy.schema.MetaData` instance.  All
      :class:`~sqlalchemy.schema.Table` objects implicitly declared by
      subclasses of the base will share this MetaData.  A MetaData instance
      will be created if none is provided.  The
      :class:`~sqlalchemy.schema.MetaData` instance will be available via the
      ``metadata`` attribute of the generated declarative base class.

    :param mapper:
      An optional callable, defaults to :class:`_orm.Mapper`. Will
      be used to map subclasses to their Tables.

    :param cls:
      Defaults to :class:`object`. A type to use as the base for the generated
      declarative base class. May be a class or tuple of classes.

    :param name:
      Defaults to ``Base``.  The display name for the generated
      class.  Customizing this is not required, but can improve clarity in
      tracebacks and debugging.

    :param constructor:
      Specify the implementation for the ``__init__`` function on a mapped
      class that has no ``__init__`` of its own.  Defaults to an
      implementation that assigns \**kwargs for declared
      fields and relationships to an instance.  If ``None`` is supplied,
      no __init__ will be provided and construction will fall back to
      cls.__init__ by way of the normal Python semantics.

    :param class_registry: optional dictionary that will serve as the
      registry of class names-> mapped classes when string names
      are used to identify classes inside of :func:`_orm.relationship`
      and others.  Allows two or more declarative base classes
      to share the same registry of class names for simplified
      inter-base relationships.

    :param type_annotation_map: optional dictionary of Python types to
        SQLAlchemy :class:`_types.TypeEngine` classes or instances.  This
        is used exclusively by the :class:`_orm.MappedColumn` construct
        to produce column types based on annotations within the
        :class:`_orm.Mapped` type.


        .. versionadded:: 2.0

        .. seealso::

            :ref:`orm_declarative_mapped_column_type_map`

    :param metaclass:
      Defaults to :class:`.DeclarativeMeta`.  A metaclass or __metaclass__
      compatible callable to use as the meta type of the generated
      declarative base class.

    .. seealso::

        :class:`_orm.registry`

    )rwr
r�r�)r
rUr�r�)ry�
generate_baser
r]r]r^�declarative_base�sn



�



�r$
c@
s�
eZ
dZUd
Zded<ded<ded<ded	<d
ed<ded
<ded<ded<ded<ddded�d|dd�Zd}dd �Z	!d~dd&d'�Ze	d�d)d*��
Z
d�d,d-�Zd�d0d1�Ze
d�d5d6��
Ze
d�d7d8��
Zd�d:d;�Zd�d=d>�Zd�dAdB�Zd�dEdF�Zd�d�dIdJ�Zd�d�dKdL�Zd�dMdN�ZdedOefd�dVdW�Zejeeeee e!e"e#e$f	dX�
e%d�dZd[��
�
Z&e%	\d�d\d\d\d\d\d\d\d\d]�d�djd[��
Z&	d�e'j(e'j(e'j(e'j(e'j(e'j(e'j(e'j(d]�d�dmd[�Z&d�dndo�Z)d�drds�Z*d�dudv�Z+	d�d�dzd{�Z,dS)�rya�Generalized registry for mapping classes.

    The :class:`_orm.registry` serves as the basis for maintaining a collection
    of mappings, and provides configurational hooks used to map classes.

    The three general kinds of mappings supported are Declarative Base,
    Declarative Decorator, and Imperative Mapping.   All of these mapping
    styles may be used interchangeably:

    * :meth:`_orm.registry.generate_base` returns a new declarative base
      class, and is the underlying implementation of the
      :func:`_orm.declarative_base` function.

    * :meth:`_orm.registry.mapped` provides a class decorator that will
      apply declarative mapping to a class without the use of a declarative
      base class.

    * :meth:`_orm.registry.map_imperatively` will produce a
      :class:`_orm.Mapper` for a class without scanning the class for
      declarative class attributes. This method suits the use case historically
      provided by the ``sqlalchemy.orm.mapper()`` classical mapping function,
      which is removed as of SQLAlchemy 2.0.

    .. versionadded:: 1.4

    .. seealso::

        :ref:`orm_mapping_classes_toplevel` - overview of class mapping
        styles.

    zclsregistry._ClsRegistryType�_class_registryz;weakref.WeakKeyDictionary[ClassManager[Any], Literal[True]]�	_managersz5weakref.WeakKeyDictionary[Mapper[Any], Literal[True]]�_non_primary_mappersr:rwz&CallableReference[Callable[..., None]]r��_MutableTypeAnnotationMapTyper�zSet[_RegistryType]�_dependents�
_dependenciesrX�_new_mappersN)rwr
r�r�r
r
r 
r!
r"
c
C
s�|
pt�}|d
ur
t
��}||_t
��|_t
��|_||_||_i|_	|d
u
r,|�
|�

t�|_t�|_
d|_tj�
dtj|<Wd
�
d
S1sKw



Y
d
S)a�Construct a new :class:`_orm.registry`

        :param metadata:
          An optional :class:`_schema.MetaData` instance.  All
          :class:`_schema.Table` objects generated using declarative
          table mapping will make use of this :class:`_schema.MetaData`
          collection.  If this argument is left at its default of ``None``,
          a blank :class:`_schema.MetaData` collection is created.

        :param constructor:
          Specify the implementation for the ``__init__`` function on a mapped
          class that has no ``__init__`` of its own.  Defaults to an
          implementation that assigns \**kwargs for declared
          fields and relationships to an instance.  If ``None`` is supplied,
          no __init__ will be provided and construction will fall back to
          cls.__init__ by way of the normal Python semantics.

        :param class_registry: optional dictionary that will serve as the
          registry of class names-> mapped classes when string names
          are used to identify classes inside of :func:`_orm.relationship`
          and others.  Allows two or more declarative base classes
          to share the same registry of class names for simplified
          inter-base relationships.

        :param type_annotation_map: optional dictionary of Python types to
          SQLAlchemy :class:`_types.TypeEngine` classes or instances.
          The provided dict will update the default type mapping.  This
          is used exclusively by the :class:`_orm.MappedColumn` construct
          to produce column types based on annotations within the
          :class:`_orm.Mapped` type.

          .. versionadded:: 2.0

          .. seealso::

              :ref:`orm_declarative_mapped_column_type_map`


        NFT)r:�weakref�WeakValueDictionaryr%
�WeakKeyDictionaryr&
r'
rwr�r��update_type_annotation_map�setr)
r*
r+
r�_CONFIGURE_MUTEX�_mapper_registries)r�rwr
r�r��lcl_metadatar]r]r^r��s"
/













"�zregistry.__init__�_TypeAnnotationMapTyperWrdcC
s|j�
d
d�|
��D�
�

dS)zQupdate the :paramref:`_orm.registry.type_annotation_map` with new
        values.c
S
si|]	\}
}t|
�
|�qSr]rA)r��typ�sqltyper]r]r^r��s��z7registry.update_type_annotation_map.<locals>.<dictcomp>N)r�r�r�)r�r�r]r]r^r/
�s

��z#registry.update_type_annotation_mapT�python_typerQ�
_do_fallbacks�"Optional[sqltypes.TypeEngine[Any]]c
sf
t|
�
r#t
|
�
r|
�|
�fg
�f
d
d�tD�
�
R}n |
j�|
�ff
}nt|
t�r3|
�dd��jD�
}n|
�|
�ff
}|D]+\}}|j�|�
}|durOt	�
|�
}|du
rgt	�|�
}|��||�}|du
rg|
Sq<|r�d}	d}
t
|
�
r�|
}	t
|	�
r|	j}	t
|	�
sxt|	�
}	d}
t|
�
r�t|
�
}	d}
|	du
r�|�|	d�}|du
r�|
du
s�J�
td|
�d|
�d	�d
�
|SdS)Nc
3
s�|]}
|
�fV
qdSr�r])r��lt�
�python_type_typer]r^�	<genexpr>���z)registry._resolve_type.<locals>.<genexpr>c
s
s�|]}
|
|
fV
qdSr�r])r��ptr]r]r^r=
�r>
�
TypeAliasType�NewTypeFzMatching the provided z 'z�' on its resolved value without matching it in the type_annotation_map is deprecated; add this type to the type_annotation_map to allow it to match explicitly.z2.0)rDrErI�
__origin__r�rhrZr�r�r7�
_type_map_get�to_instance�_resolve_for_python_typerG�	__value__rBrFrC�
_resolve_typer?)r�r7
r8
�searchr?
�	flattened�sql_type�
sql_type_inst�resolved_sql_type�python_type_to_check�kind�res_after_fallbackr]r;
r^rG
�sn

��














�
�




�
�




�


�zregistry._resolve_type�FrozenSet[Mapper[Any]]c

C
std
d�|j
D�
�
�|j�
S)z9read only collection of all :class:`_orm.Mapper` objects.c
s
s�|]}
|
jV
qdSr�)
r
�r�r�r]r]r^r=
(s�z#registry.mappers.<locals>.<genexpr>)�	frozensetr&
�unionr'
r�r]r]r^�mappers$s
�zregistry.mappersrxcC
s(|
|urdS|
j�
|�

|j�
|
�

dSr�)r)
�addr*
)r�ryr]r]r^�_set_depends_on,s



zregistry._set_depends_onr
�Mapper[Any]cC
s,d
|
_|j
rdS|�|h
�
D]}d
|_
qdS�NT)�_ready_for_configurer+
�_recurse_with_dependents)r�r
r�r]r]r^�_flag_new_mapper2s



�zregistry._flag_new_mapper�
registries�Set[RegistryType]�Iterator[RegistryType]cc
�X�|
}t�}|r*|�
�}|�|�

|�|j�|�
�

|V
|�|j�|�
�

|sdSdSr�)r0
�poprU
r�r)
�
difference�rUr\
�todo�doner�r]r]r^rZ
:s�





�z!registry._recurse_with_dependentscc
r_
r�)r0
r`
rU
r�r*
ra
rb
r]r]r^�_recurse_with_dependenciesMs�




�z#registry._recurse_with_dependencies�Iterator[Mapper[Any]]c

C
s,t�
d
d�t|j�
D�
dd�t|j�
D�
�S)Nc
s
s,�|]}
|
jr|
j
js|
j
jr|
j
V
qdSr�)r�r
�
configuredrY
rQ
r]r]r^r=
cs�
���

�z1registry._mappers_to_configure.<locals>.<genexpr>c
s
s �|]}
|
js|
j
r|
V
qdSr�)rg
rY
)r��npmr]r]r^r=
js�
��

�)�	itertools�chain�listr&
r'
r�r]r]r^�_mappers_to_configureas

���zregistry._mappers_to_configure�	np_mappercC
sd
|j|
<dSrX
)
r'
)r�rm
r]r]r^�_add_non_primary_mapperqr�z registry._add_non_primary_mapperrUrVcC
st�
|
j|
|j�
dSr�)r�remove_classrlr%
�r�rUr]r]r^�_dispose_clsts
zregistry._dispose_clsr��ClassManager[Any]cC
s8d
|j|
<|
j
rt�d|
j�
�
|
jdusJ�
||
_dS)NTz1Class '%s' already has a primary mapper defined. )r&
r�r4�
ArgumentErrorr\ry)r�r�r]r]r^�_add_managerws





��

zregistry._add_managerF�cascadecC
�tj
|h
|
d
�
dS)a]Configure all as-yet unconfigured mappers in this
        :class:`_orm.registry`.

        The configure step is used to reconcile and initialize the
        :func:`_orm.relationship` linkages between mapped classes, as well as
        to invoke configuration events such as the
        :meth:`_orm.MapperEvents.before_configured` and
        :meth:`_orm.MapperEvents.after_configured`, which may be used by ORM
        extensions or user-defined extension hooks.

        If one or more mappers in this registry contain
        :func:`_orm.relationship` constructs that refer to mapped classes in
        other registries, this registry is said to be *dependent* on those
        registries. In order to configure those dependent registries
        automatically, the :paramref:`_orm.registry.configure.cascade` flag
        should be set to ``True``. Otherwise, if they are not configured, an
        exception will be raised.  The rationale behind this behavior is to
        allow an application to programmatically invoke configuration of
        registries while controlling whether or not the process implicitly
        reaches other registries.

        As an alternative to invoking :meth:`_orm.registry.configure`, the ORM
        function :func:`_orm.configure_mappers` function may be used to ensure
        configuration is complete for all :class:`_orm.registry` objects in
        memory. This is generally simpler to use and also predates the usage of
        :class:`_orm.registry` objects overall. However, this function will
        impact all mappings throughout the running Python process and may be
        more memory/time consuming for an application that has many registries
        in use for different purposes that may not be needed immediately.

        .. seealso::

            :func:`_orm.configure_mappers`


        .. versionadded:: 1.4.0b2

        �
ru
N)r�_configure_registries�r�ru
r]r]r^�	configure�s'zregistry.configurecC
rv
)a�Dispose of all mappers in this :class:`_orm.registry`.

        After invocation, all the classes that were mapped within this registry
        will no longer have class instrumentation associated with them. This
        method is the per-:class:`_orm.registry` analogue to the
        application-wide :func:`_orm.clear_mappers` function.

        If this registry contains mappers that are dependencies of other
        registries, typically via :func:`_orm.relationship` links, then those
        registries must be disposed as well. When such registries exist in
        relation to this one, their :meth:`_orm.registry.dispose` method will
        also be called, if the :paramref:`_orm.registry.dispose.cascade` flag
        is set to ``True``; otherwise, an error is raised if those registries
        were not already disposed.

        .. versionadded:: 1.4.0b2

        .. seealso::

            :func:`_orm.clear_mappers`

        rw
N)r�_dispose_registriesry
r]r]r^�dispose�szregistry.disposecC
s8d
|
jvr|
j
}|��
|
j}|�|�

tj�|�

dS)Nr
)rgr
�_set_dispose_flagsr\rq
r�_instrumentation_factory�
unregister)r�r�r
r\r]r]r^�_dispose_manager_and_mapper�s





z$registry._dispose_manager_and_mapperr
r
r�r�rbr�rc	C
s�|j}t
|t�r|f
p
|}t||d
�}t
|t�r|j|d<|jdu
r(|j|d<d|d<|
r2|
|d<t|d�r@ddd�}||d<||||�S)a�	Generate a declarative base class.

        Classes that inherit from the returned class object will be
        automatically mapped using declarative mapping.

        E.g.::

            from sqlalchemy.orm import registry

            mapper_registry = registry()

            Base = mapper_registry.generate_base()


            class MyClass(Base):
                __tablename__ = "my_table"
                id = Column(Integer, primary_key=True)

        The above dynamically generated class is equivalent to the
        non-dynamic example below::

            from sqlalchemy.orm import registry
            from sqlalchemy.orm.decl_api import DeclarativeMeta

            mapper_registry = registry()


            class Base(metaclass=DeclarativeMeta):
                __abstract__ = True
                registry = mapper_registry
                metadata = mapper_registry.metadata

                __init__ = mapper_registry.constructor

        .. versionchanged:: 2.0 Note that the
           :meth:`_orm.registry.generate_base` method is superseded by the new
           :class:`_orm.DeclarativeBase` class, which generates a new "base"
           class using subclassing, rather than return value of a function.
           This allows an approach that is compatible with :pep:`484` typing
           tools.

        The :meth:`_orm.registry.generate_base` method provides the
        implementation for the :func:`_orm.declarative_base` function, which
        creates the :class:`_orm.registry` and base class all at once.

        See the section :ref:`orm_declarative_mapping` for background and
        examples.

        :param mapper:
          An optional callable, defaults to :class:`_orm.Mapper`.
          This function is used to generate new :class:`_orm.Mapper` objects.

        :param cls:
          Defaults to :class:`object`. A type to use as the base for the
          generated declarative base class. May be a class or tuple of classes.

        :param name:
          Defaults to ``Base``.  The display name for the generated
          class.  Customizing this is not required, but can improve clarity in
          tracebacks and debugging.

        :param metaclass:
          Defaults to :class:`.DeclarativeMeta`.  A metaclass or __metaclass__
          compatible callable to use as the meta type of the generated
          declarative base class.

        .. seealso::

            :ref:`orm_declarative_mapping`

            :func:`_orm.declarative_base`

        )ryrwrrNr�Tr�__mapper_cls__�__class_getitem__rUr�rarrWc
S
r�r�r]rkr]r]r^r�
/r�z1registry.generate_base.<locals>.__class_getitem__)rUr�rarrWr�)rwr��tuple�dictrhrrr�r�)	r�r
rUr�r�rwr{�
class_dictr�
r]r]r^r#
�sP










zregistry.generate_basers�_registry__clsc
C
r�r�r])r�r�
r]r]r^�mapped_as_dataclass7szregistry.mapped_as_dataclass.r��
Literal[None]r�r�r�r�r�r�r�r�r�r��Callable[[Type[_O]], Type[_O]]c

C
r�r�r])
r�r�
r�r�r�r�r�r�r�r�r]r]r^r�
Gs
�Optional[Type[_O]]�/Union[Type[_O], Callable[[Type[_O]], Type[_O]]]c

s.d��
�������f	dd�}
|
r|
|
�
S|
S)a_
Class decorator that will apply the Declarative mapping process
        to a given class, and additionally convert the class to be a
        Python dataclass.

        .. seealso::

            :ref:`orm_declarative_native_dataclasses` - complete background
            on SQLAlchemy native dataclass mapping


        .. versionadded:: 2.0


        rUrVrWc


s0t|d
���
�����d��
t
�||j�
|S)Nr�r�)�setattrr&rgr��	r�r�r�r�r�r�r�r�r�r]r^r�ts









��
z.registry.mapped_as_dataclass.<locals>.decorateN�rUrVrWrVr])r�r�
r�r�r�r�r�r�r�r�r�r]r�
r^r�
Vs
cC
st||
|
j
�
|
S)
a�Class decorator that will apply the Declarative mapping process
        to a given class.

        E.g.::

            from sqlalchemy.orm import registry

            mapper_registry = registry()


            @mapper_registry.mapped
            class Foo:
                __tablename__ = "some_table"

                id = Column(Integer, primary_key=True)
                name = Column(String)

        See the section :ref:`orm_declarative_mapping` for complete
        details and examples.

        :param cls: class to be mapped.

        :return: the class that was passed.

        .. seealso::

            :ref:`orm_declarative_mapping`

            :meth:`_orm.registry.generate_base` - generates a base class
            that will apply Declarative mapping to subclasses automatically
            using a Python metaclass.

        .. seealso::

            :meth:`_orm.registry.mapped_as_dataclass`

        )r&rgrp
r]r]r^�mapped�s&
zregistry.mappedr}�Callable[[Type[_T]], Type[_T]]c

sd��
fdd�}|S)a�
        Class decorator which will invoke
        :meth:`_orm.registry.generate_base`
        for a given base class.

        E.g.::

            from sqlalchemy.orm import registry

            mapper_registry = registry()


            @mapper_registry.as_declarative_base()
            class Base:
                @declared_attr
                def __tablename__(cls):
                    return cls.__name__.lower()

                id = Column(Integer, primary_key=True)


            class MyMappedClass(Base): ...

        All keyword arguments passed to
        :meth:`_orm.registry.as_declarative_base` are passed
        along to :meth:`_orm.registry.generate_base`.

        rUr�rWc


s"|�d
<|j�d<�
j
di��
�
S)NrUr�r])rlr#
r��r}r�r]r^r��s



z.registry.as_declarative_base.<locals>.decorateN�rUr�rWr�r])r�r}r�r]r�
r^�as_declarative_base�szregistry.as_declarative_base�
Mapper[_O]cC
st||
|
j
�
|
jS)
a�Map a class declaratively.

        In this form of mapping, the class is scanned for mapping information,
        including for columns to be associated with a table, and/or an
        actual table object.

        Returns the :class:`_orm.Mapper` object.

        E.g.::

            from sqlalchemy.orm import registry

            mapper_registry = registry()


            class Foo:
                __tablename__ = "some_table"

                id = Column(Integer, primary_key=True)
                name = Column(String)


            mapper = mapper_registry.map_declaratively(Foo)

        This function is more conveniently invoked indirectly via either the
        :meth:`_orm.registry.mapped` class decorator or by subclassing a
        declarative metaclass generated from
        :meth:`_orm.registry.generate_base`.

        See the section :ref:`orm_declarative_mapping` for complete
        details and examples.

        :param cls: class to be mapped.

        :return: a :class:`_orm.Mapper` object.

        .. seealso::

            :ref:`orm_declarative_mapping`

            :meth:`_orm.registry.mapped` - more common decorator interface
            to this function.

            :meth:`_orm.registry.map_imperatively`

        )r&rgrfrp
r]r]r^�map_declaratively�s/
zregistry.map_declarativelyr\�local_tabler
cK
st||
||�S)
a�Map a class imperatively.

        In this form of mapping, the class is not scanned for any mapping
        information.  Instead, all mapping constructs are passed as
        arguments.

        This method is intended to be fully equivalent to the now-removed
        SQLAlchemy ``mapper()`` function, except that it's in terms of
        a particular registry.

        E.g.::

            from sqlalchemy.orm import registry

            mapper_registry = registry()

            my_table = Table(
                "my_table",
                mapper_registry.metadata,
                Column("id", Integer, primary_key=True),
            )


            class MyClass:
                pass


            mapper_registry.map_imperatively(MyClass, my_table)

        See the section :ref:`orm_imperative_mapping` for complete background
        and usage examples.

        :param class\_: The class to be mapped.  Corresponds to the
         :paramref:`_orm.Mapper.class_` parameter.

        :param local_table: the :class:`_schema.Table` or other
         :class:`_sql.FromClause` object that is the subject of the mapping.
         Corresponds to the
         :paramref:`_orm.Mapper.local_table` parameter.

        :param \**kw: all other keyword arguments are passed to the
         :class:`_orm.Mapper` constructor directly.

        .. seealso::

            :ref:`orm_imperative_mapping`

            :ref:`orm_declarative_mapping`

        r+)r�r\r�
r}r]r]r^�map_imperativelys8zregistry.map_imperatively)rwr
r
r 
r�r!
r�r"
)r�r4
rWrd)
T)r7
rQr8
rXrWr9
)rWrP
)ryrxrWrd)r
rW
rWrd)r\
r]
rWr^
)rWrf
)rm
rW
rWrd)rUrVrWrd)r�rr
rWrdr�)ru
rXrWrd)
r
r
rUr�r�rbr�r�rWr)r�
rVrWrV)
.)r�
r�
r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rWr�
r�)r�
r�
r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rWr�
r�
�r}rrWr�
)rUrVrWr�
)r\rVr�
r
r}rrWr�
)-rlrmrnrrr�r(r�r/
rG
�propertyrT
rV
r[
r�rZ
re
rl
rn
rq
rt
rz
r|
r�
r�rvr#
�
compat_typing�dataclass_transformr0r1r-r.rrrrrr
r�
r8r�r�
r�
r�
r�
r]r]r]r^ryVs�

 










�
D�Q









)



�i







��

�






��





�
5
)
%5�ryr}r�
cK
s2|�d
d�|�dd�}
}t
|
|d�jdi|�
�
S)a�
    Class decorator which will adapt a given class into a
    :func:`_orm.declarative_base`.

    This function makes use of the :meth:`_orm.registry.as_declarative_base`
    method, by first creating a :class:`_orm.registry` automatically
    and then invoking the decorator.

    E.g.::

        from sqlalchemy.orm import as_declarative


        @as_declarative()
        class Base:
            @declared_attr
            def __tablename__(cls):
                return cls.__name__.lower()

            id = Column(Integer, primary_key=True)


        class MyMappedClass(Base): ...

    .. seealso::

        :meth:`_orm.registry.as_declarative_base`

    rwNr
)rwr
r])r`
ryr�
)r}rwr
r]r]r^�as_declarativeMs


�
���r�
�Optional[Mapper[Any]]c
C
s(t|�
}
|
durt
�|�
rt
�|�

|
Sr�)r r)�has_cls�raise_unmapped_for_cls)rU�mpr]r]r^�_inspect_decl_metaus






r�
)rUrVrWrXr�)r�rbr�rXrWr�r�
)rUr�rWrd)rUr�r
r�rWrd)r
rVrarbr
r
rWrd)rwr
r
r
rUr�r�rbr
r 
r�r!
r�r"
r�r�rWrr�
)rUr�rWr�
)�rr�
__future__rri
r�r>rrrrrrr	r
rrr
rrrrrrr,
�rrrrr�_orm_constructorsrrrrrrr
r r!r"r#�	decl_baser%r&r'r(r)r*r,�descriptor_propsr-r.r�r
r/�
propertiesr0�
relationshipsr1�stater2r4r5r6�sqlr7�sql.baser8�sql.elementsr9�
sql.schemar:�sql.selectabler;r<r=r�
r?�util.typingr@rBrCrDrErFrGrHrIrJ�_typingrKrLrMrNrO�sql._typingrP�sql.type_apirQrRrTr4
r(
�_DeclaredAttrDecoratedr_rhr`�Inspectablerpr�
rurvr�r�r��_MappedAttributer�r�r�r�r�r�r
r
r
r�r$
ryrxr�
�	_inspectsr�
r]r]r]r^�<module>
s2
















































































�


�







��
�*A	

,)
A
�
V
�
k






�{u
(
�