HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
$ pwd: /usr/local/lib/python3.10/dist-packages/sqlalchemy/orm/__pycache__/
Upload Files
File: //usr/local/lib/python3.10/dist-packages/sqlalchemy/orm/__pycache__/decl_base.cpython-310.pyc
o

���gXE�@s�dZddlmZddlZddlZddlZddlmZddlmZddlm	Z	ddlm
Z
ddlmZdd	lmZdd
lm
Z
ddlmZddlmZdd
lmZddlmZddlmZddlmZddlmZddlmZddlmZddlZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!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*m0Z0dd(l1m2Z2dd)l3m4Z4dd*l3m5Z5dd+l6m7Z7dd,l6m8Z8dd-l6m9Z9dd.l6m:Z:d/d0lm;Z;d/dlmZd/d1lm6Z6d/d2l<m=Z=d/d3l>m?Z?d/d4l@mAZAd/d5l@mBZBd/d6l6mCZCd/d7lDmEZEd/d8lDmFZFd/d9lDmGZGd/d:lDmHZHd/d;lDmIZId/d<lDmJZJe�r�dd=lmKZKdd>lmLZLdd?l$mMZMdd@lNmOZOddAlmPZPd/dBlQmRZRd/dCl@mSZSd/dDlTmUZUedEedF�ZVe
eWefZXeeedGfe
eWeffZYGdHdI�dIeIe �ZZGdJdK�dKeZe eI�Z[GdLdM�dMeJ�Z\d�dRdS�Z]d�dUdV�Z^d�dXdY�Z_	Zd�d�d_d`�Z`d�dcdd�Zad�djdk�Zbd�dqdr�Zce6�dds�d�dvdw��Zed�dydz�ZfGd{d|�d|�ZgGd}d~�d~eg�ZhGdd��d�e�ZiGd�d��d�eg�Zje6�dds�d�d�d���ZkGd�d��d�ej�Zld�d�d��Zmd�d�d��Znd�d�d��Zod�eo_pd�d�d��ZqdS)�z(Internal implementation for declarative.�)�annotationsN)�Any)�Callable)�cast)�Dict)�Iterable)�List)�Mapping)�
NamedTuple)�NoReturn)�Optional)�Sequence)�Tuple)�Type)�
TYPE_CHECKING)�TypeVar)�Union�)�
attributes)�clsregistry)�exc)�instrumentation)�	mapperlib)�_O)�attr_is_internal_proxy)�InstrumentedAttribute)�QueryableAttribute)�_is_mapped_class)�InspectionAttr)�CompositeProperty)�SynonymProperty)�_AttributeOptions)�_DCAttributeOptions)�_IntrospectsAnnotations)�_MappedAttribute)�_MapsColumns)�MapperProperty)�Mapper)�ColumnProperty)�MappedColumn)�_extract_mapped_subtype)�_is_mapped_annotation)�class_mapper)�de_stringify_annotation�)�event)�util)�
expression)�_NoArg)�Column)�Table)�topological)�_AnnotationScanType)�get_args)�
is_fwd_ref)�
is_literal)�Protocol)�	TypedDict)�
_ClassDict)�
_RegistryType)�Mapped)�
declared_attr)�ClassManager)�NamedColumn)�MetaData)�
FromClause�_T)�bound.c@s4eZdZUdZded<ded<ded<ddd
�ZdS)�MappedClassProtocolz�A protocol representing a SQLAlchemy mapped class.

    The protocol is generic on the type of class, use
    ``MappedClassProtocol[Any]`` to allow any mapped class.
    �str�__name__�
Mapper[_O]�
__mapper__rC�	__table__�kwr�returnrcK�dS�N�)�selfrLrPrP�C/usr/local/lib/python3.10/dist-packages/sqlalchemy/orm/decl_base.py�__call__e�zMappedClassProtocol.__call__N)rLrrMr)rH�
__module__�__qualname__�__doc__�__annotations__rSrPrPrPrRrFZs
rFc@sNeZdZUdZded<ded<ded<ded	<d
ed<ddd�Zddd�ZdS)�_DeclMappedClassProtocolz:Internal more detailed version of ``MappedClassProtocol``.rB�metadatarG�
__tablename__�
_MapperKwArgs�__mapper_args__�Optional[_TableArgsType]�__table_args__�Optional[_DataclassArguments]�_sa_apply_dc_transformsrM�NonecCrNrOrP�rQrPrPrR�__declare_first__qrTz*_DeclMappedClassProtocol.__declare_first__cCrNrOrPrcrPrPrR�__declare_last__srTz)_DeclMappedClassProtocol.__declare_last__N�rMrb)rHrUrVrWrXrdrerPrPrPrRrYhs

rYc@sNeZdZUded<ded<ded<ded<ded<ded<ded<d	ed
<dS)�_DataclassArgumentszUnion[_NoArg, bool]�init�repr�eq�order�unsafe_hash�
match_args�kw_onlyz'Union[_NoArg, Callable[..., Type[Any]]]�dataclass_callableN�rHrUrVrXrPrPrPrRrgvs
rg�cls�	Type[Any]rM�3Optional[Union[_DeferredMapperConfig, Mapper[Any]]]cCs,t�|�r
t�|�St|�rt|dd�SdS)NF)�	configure)�_DeferredMapperConfig�has_cls�config_for_clsrr,�rqrPrPrR�_declared_mapping_info�s


ry�boolcCs*t�|�r
t|ddd�St|�rdSdS)a�return True if this class will be used as a superclass to set in
    'inherits'.

    This includes deferred mapper configs that aren't mapped yet, however does
    not include classes with _sa_decl_prepare_nocascade (e.g.
    ``AbstractConcreteBase``); these concrete-only classes are not set up as
    "inherits" until after mappers are configured using
    mapper._set_concrete_base()

    �_sa_decl_prepare_nocascadeT��strictF)rurv�_get_immediate_cls_attrrrxrPrPrR�_is_supercls_for_inherits�s
�r�Optional[Type[Any]]cCsX|turdS|j�dd�r!|jD]}t|�}|dur|SqdSt|�}|r*|jS|S)N�__abstract__F)�object�__dict__�get�	__bases__�"_resolve_for_abstract_or_classical�_dive_for_cls_manager�class_)rq�base_�sup�
clsmanagerrPrPrRr��s
�r�F�attrnamerGr}�
Optional[Any]cCs�|dksJ�t|t�s
dS||jvrt||�S|jdd�D]#}t|�du}||jvrA||us:|r7||jvrAn	|sAt||�SqdS)a�return an attribute of the class that is either present directly
    on the class, e.g. not on a superclass, or is from a superclass but
    this superclass is a non-mapped mixin, that is, not a descendant of
    the declarative base and is also not classically mapped.

    This is used to detect attributes that indicate something about
    a mapped class independently from any mapped classes that it may
    inherit from.

    r�Nr)�
issubclassr�r��getattr�__mro__r�r�)rqr�r}�base�_is_classical_inheritsrPrPrRr~�s"



���r~�Type[_O]�Optional[ClassManager[_O]]cCs&|jD]
}t�|�}|r|SqdSrO)r�r�opt_manager_of_class)rqr��managerrPrPrRr��s
��r��registryr=�dict_r<�Optional[_MapperConfig]cCst�|||di�SrO)�
_MapperConfig�
setup_mapping)r�rqr�rPrPrR�_as_declarative�sr��table�Optional[FromClause]�	mapper_kwr\rIcCst||||�td|�jS)NzMappedClassProtocol[_O])�_ImperativeMapperConfigrrJ)r�rqr�r�rPrPrR�_mapper�sr�zsqlalchemy.orm.decl_api�objrcCstjjj}t||tjf�SrO)r0�	preloaded�orm_decl_api�_declared_attr_common�
isinstance�
classproperty)r�r�rPrPrR�_is_declarative_propss
r��namecCs.t|�rt|dd�rt�d||f�dSdS)N�
_cascadingFz~@declared_attr.cascading is not supported on the %s attribute on class %s.  This attribute invokes for subclasses in any case.T)r�r�r0�warn)r�r�rqrPrPrR�_check_declared_props_nocascades��r�c@sjeZdZUdZded<ded<ded<ded	<ed'dd��Zd(dd�Zd)dd�Zd*d+d!d"�Z	d,d$d%�Z
d&S)-r�)rq�	classname�
properties�declared_attr_reg�__weakref__rrrqrGr�z_util.OrderedDict[str, Union[Sequence[NamedColumn[Any]], NamedColumn[Any], MapperProperty[Any]]]r�zDict[declared_attr[Any], Any]r�r�r=�cls_r�r�r<r�r�r�r\rMr�cCsxt�|�}|r|j|urt�d|�d���|j�dd�rdSt|ddd�p)t|d�}|r4t	|||||�St
|||||�S)	N�Class z, already has been instrumented declarativelyr�Fr{Tr|�_sa_decl_prepare)rr�r�r�InvalidRequestErrorr�r�r~�hasattrru�_ClassScanMapperConfig)rqr�r�r�r�r�r��	defer_maprPrPrRr�*s&
	
���
�
�z_MapperConfig.setup_mappingcCszt�|td�|_|j|_t��|_i|_|�	dd�s(t
j|jd|||jd�dSt
�|j�}|r3|js;t�d|j��dS)Nr��non_primaryF)�finalizer��declarative_scan�init_methodztClass %s has no primary mapper configured.  Configure a primary mapper first before setting up a non primary Mapper.)r0�assert_arg_type�typerqrHr��OrderedDictr�r�r�r�register_class�constructorrr��	is_mappedrr�)rQr�r�r�r�rPrPrR�__init__Is(

�
���z_MapperConfig.__init__r��valuerDcCst�|j�}|�||�|SrO)r�manager_of_classrq�install_member)rQr�r�r�rPrPrR�set_cls_attributeesz_MapperConfig.set_cls_attribute.�Mapper[Any]cCst��rO)�NotImplementedError�rQr�rPrPrR�mapj�z_MapperConfig.maprbcCs|�|�dSrO)r�r�rPrPrR�_early_mappingmsz_MapperConfig._early_mappingN)r�r=r�r�r�r<r�r�r�r\rMr�)r�r=r�rrr�r\)r�rGr�rDrMrD).�r�r\rMr��r�r\rMrb)rHrUrV�	__slots__rX�classmethodr�r�r�r�r�rPrPrPrRr�s


r�cs<eZdZdZd�fd
d�Zejfddd�Zddd�Z�Z	S)r�)�local_table�inheritsr�r=r�r�r�r�r�r\cs~t��|||�|�d|�|_tj�#|�dd�s#t�|j	|j
|j�|�|�|�
|�Wd�dS1s8wYdS)NrKr�F)�superr�r�r�r�_CONFIGURE_MUTEXr�r�	add_classr�rq�_class_registry�_setup_inheritancer�)rQr�r�r�r���	__class__rPrRr�ts�
"�z _ImperativeMapperConfig.__init__rMr�cCs"t}|�d||j|jfi|���S)NrJ)r'r�rqr��rQr��
mapper_clsrPrPrRr��s
�z_ImperativeMapperConfig.maprbcCs�|j}|�dd�}|durAg}|jD]}t|�}|durqt|�r*||vr*|�|�q|r@t|�dkr<t�d||f��|d}nt	|t
�rI|j}||_dS)Nr�r�&Class %s has multiple mapped bases: %rr)
rqr�r�r�r�append�lenrr�r�r'r�r�)rQr�rqr��inherits_searchr��crPrPrRr��s.

����

z*_ImperativeMapperConfig._setup_inheritance)r�r=r�r�r�r�r�r\r�r�)
rHrUrVr�r�r0�
EMPTY_DICTr�r��
__classcell__rPrPr�rRr�qs
r�c@sFeZdZUded<ded<ded<ded<d	ed
<ded<d
ed<dS)�_CollectedAnnotationr6�raw_annotationzOptional[Type[Mapped[Any]]]�mapped_containerzUnion[_AnnotationScanType, str]�extracted_mapped_annotationrz�is_dataclassr�
attr_valuerG�originating_modulerr�originating_classNrprPrPrPrRr��s
r�cs�eZdZUdZdZded<ded<ded<d	ed
<ded<ded
<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded <ded!<d"ed#<	ded$<	du�fd+d,�Zdvd/d0�Zdwd3d4�Zhd5�Z	e
�d6�Zdxd9d:�Z
dvd;d<�Zdvd=d>�ZedydAdB��ZedzdEdF��Zed{dHdI��Zd|dTdU�Zd}dXdY�Zd~d^d_�Zdvd`da�Zdvdbdc�Zdd�dedf�Zd�djdk�Zd�dldm�Zd�dndo�Zd�dpdq�Zejfd�dsdt�Z �Z!S)�r�)r��clsdict_view�collected_attributes�collected_annotationsr��persist_selectable�declared_columns�column_ordering�
column_copies�
table_args�	tablename�mapper_args�mapper_args_fn�table_fnr��single�allow_dataclass_fields�dataclass_setup_arguments�is_dataclass_prior_to_mapping�allow_unmapped_annotationsFr=r�r<r�zDict[str, _CollectedAnnotation]r��Dict[str, Any]r�r�r�r�zutil.OrderedSet[Column[Any]]r�zDict[Column[Any], int]r�zRDict[Union[MappedColumn[Any], Column[Any]], Union[MappedColumn[Any], Column[Any]]]r�z
Optional[str]r��Mapping[str, Any]r�r^r�z&Optional[Callable[[], Dict[str, Any]]]r�r�r�rzr�r�r�r`r�r�r�r�r�r�r�r\c	sV|rt�|�ntj|_t��|||�||_d|_i|_i|_	t�
�|_i|_i|_
d|_t|jdd�|_}t|jdd�pBt|j�|_t�|�|_}t|d�}|rU|r\|r\t�d��t|o`|�|_|��|��|��tj�/t �!|j"|j|j#�|�$|�|�%�|�&�|�'|�|�(|�|�)|�Wd�dS1s�wYdS)NFra�__allow_unmapped__�__sa_dataclass_metadata_key__z�SQLAlchemy mapped dataclasses can't consume mapping information from dataclass.Field() objects if the immediate class is not already a dataclass.)*r0�
immutabledictr�r�r�r�r�r�r�r��
OrderedSetr�r�r�r�r�rqr�rzr��dataclassesr�r�r~rr�r��_setup_declared_events�_scan_attributes�_setup_dataclasses_transformsrr�rr�r�r��_setup_inheriting_mapper�_extract_mappable_attributes�_extract_declared_columns�_setup_table�_setup_inheriting_columnsr�)	rQr�r�r�r�r��dca�cld�sdkr�rPrRr��sT�

���
�
�	�


"�z_ClassScanMapperConfig.__init__rMrbcsTt�jd�rt�td�d�fdd��}t�jd�r(t�td�d�fd	d
��}dSdS)Nre�after_configuredrMrbc�td�j���dS�N�_DeclMappedClassProtocol[Any])rrqrerPrcrPrRrI��
zG_ClassScanMapperConfig._setup_declared_events.<locals>.after_configuredrd�before_configuredcrr)rrqrdrPrcrPrRrQrzH_ClassScanMapperConfig._setup_declared_events.<locals>.before_configuredrf)r~rqr/�listens_forr')rQrrrPrcrRrFs

�z-_ClassScanMapperConfig._setup_declared_eventsrq�Callable[[str, Any], bool]csz|jr	t�d��nd��sd�fd	d
�}|S�fdd�t���D���fd
d�t���D��t��d����fdd
�}|S)z�Produce a function that checks if a class has overridden an
        attribute, taking SQLAlchemy-enabled dataclass fields into account.

        r�N�keyrGr�rrMrzcst�||�|uSrO)r�)rr�rxrPrR�attribute_is_overriddenhszR_ClassScanMapperConfig._cls_attr_override_checker.<locals>.attribute_is_overriddenc�$i|]}�|jvr|j|j��qSrP�rZr���.0�f��sa_dataclass_metadata_keyrPrR�
<dictcomp>l�

�zE_ClassScanMapperConfig._cls_attr_override_checker.<locals>.<dictcomp>crrPrrrrPrRrqr cs�t|�r|j}��|��}t|�r|j}||urdS|�ur dS��|��}t�||�}||ur2dS|�ur=t|t�r=dS||urCdS|�urIdSdS)NFT)r��fgetr�r�r�r)rr��ret�	all_field)�absent�all_datacls_fieldsrq�local_datacls_fieldsrPrRrys,
�)rrGr�rrMrz)r�r~r0�dataclass_fields�local_dataclass_fieldsr�)rQrqrrP)r$r%rqr&rrR�_cls_attr_override_checkerWs"�9
��
�(z1_ClassScanMapperConfig._cls_attr_override_checker>rKr[r_r]z^(?:_sa_|__)rr�2Callable[[], Iterable[Tuple[str, Any, Any, bool]]]cs�t�|��t|��|j�|j���fdd�t�t��t���D��|jr*t|d��nd��s9d���fdd�}|Sd	d
�t�	|�D����d������fdd�}|S)
z�produce a function to iterate the "attributes" of a class
        which we want to consider for mapping, adjusting for SQLAlchemy fields
        embedded in dataclass fields.

        cs"g|]
}��|�r
|�vr|�qSrP)�match)r�n)�_include_dunders�_match_exclude_dundersrPrR�
<listcomp>�s��z=_ClassScanMapperConfig._cls_attr_resolver.<locals>.<listcomp>r�NrM�$Iterable[Tuple[str, Any, Any, bool]]cs��fdd��D�S)Nc3s(�|]}|��|���|�dfVqdS)FN�r�)rr�)�cls_annotations�cls_varsrPrR�	<genexpr>�s���
�z`_ClassScanMapperConfig._cls_attr_resolver.<locals>.local_attributes_for_class.<locals>.<genexpr>rPrP)r2r3�namesrPrR�local_attributes_for_class�s�zM_ClassScanMapperConfig._cls_attr_resolver.<locals>.local_attributes_for_classcS�i|]}|j|�qSrP)r�)r�fieldrPrPrRr�s�z=_ClassScanMapperConfig._cls_attr_resolver.<locals>.<dictcomp>c3sf��D]-}��|d�}|r#�|jvr#|jt|j����|j�dfVq|��|���|�dfVqdS)NTF)r�rZr��_as_dc_declaredattr)r�r8)r2r3r'�fixed_sa_dataclass_metadata_keyr5rrPrRr6�s������)rMr0)
r0�get_annotations�varsr-r.�merge_lists_w_ordering�listr�r~r()rQrqr6rP)r-r.r2r3r'r:r5rrR�_cls_attr_resolver�s.
���"��z)_ClassScanMapperConfig._cls_attr_resolverc	s||j}td|��|j}|j}|j}|j}d}d}}d}	d}
d|v}|�|j�}g}
|jD])}||uo6t|�}|�	|�}|sK||urK|�
||||�}ni}|
�||||f�q-|
D�]�\}}}}|�|�|�D�]�\}}}}||vr�|dkr�t
|||�}|s�|r�|r�d�fdd�}|}qh|dkr�t
|||�}|
s�|r�|r��j}
qh|dkr�t
|||�}|r�|	s�d�fd
d�}|}	qh|dkr�t
|||�}|s�|r�|r�j}t|tttd�f�s�t�d
��||ur�d}qhJ�|r�t|�r�|js�t�d|j|||f�qh||u�r�t|ttf��rqht|t��rt�d��t|��r�|du�sJ�|j�rF||v�r1t�d||f�|� ||�||<||<}t!|||�n6|�rZt"||d�}t|t#��sY|�$�}nt"||�}t|t#��rtt%|��rtt|j&t��st|j'}|||<||<t|ttf��r�|j(du�r�|j)|_(|�*||�+�|d|�qht,|||��r�|�s�||v�s�||d��s�J�qh|�-|||�qh|�r�||v�s�|||u�r�|||��r�J�t|��r�|�$�}|||<|�*|||d|�qh|�*|||d|�}|du�o�|j.du}|du�r|j/n|}|du�r|�s|�r|du�r|nt�||<qh||v�r&|||<qhqY|�r0|
�s0d}||_0|
|_1||_2|	|_3dS)NrrKr]rMr�cs
t�j�SrO)�dictr]rP��cls_as_DeclrPrR�_mapper_args_fnAs
z@_ClassScanMapperConfig._scan_attributes.<locals>._mapper_args_fnr[rCcs�jSrO)rKrPrArPrR�	_table_fnWr�z:_ClassScanMapperConfig._scan_attributes.<locals>._table_fnr_z3__table_args__ value must be a tuple, dict, or NoneTFz�Regular (i.e. not __special__) attribute '%s.%s' uses @declared_attr, but owning class %s is mapped - not applying to subclass %s.z�Mapper properties (i.e. deferred,column_property(), relationship(), etc.) must be declared as @declared_attr callables on declarative mixin classes.  For dataclass field() objects, use a lambda:zXAttribute '%s' on class %s cannot be processed due to @declared_attr.cascading; skipping)rMr�)rMrC)4rqrr�r�r�r-r)r�rr?�_produce_column_copiesr��updater�r[r_r��tupler@r�r�
ArgumentErrorr��_quietr0r�rHr3r)r&r�r��__get__�setattrr�rr!r�original_property�
descriptor�docrW�_collect_annotation�_collect_return_annotationr+�_warn_for_decl_attributesr�r�r�r�r�r�)rQrqr�r�r�r-r�r��inherited_table_argsr�r��fixed_tabler�basesr��class_mappedr6�locally_collected_columnsr�r��
annotation�is_dataclass_field�
check_declrCrDr"�collected_annotationr��
generated_objrPrArRr�sv


����
����	�����������
�

��
��
�������
�


�
�
�
��
��
���j
z'_ClassScanMapperConfig._scan_attributesc	s|�j}|sdSd�jjvrt�d�j�d���d�jjvr't�d�j�d���t�t��d��fdd
��t�	�j�}|dus@J��fdd���fdd��j
��D�D�}�rz���D]\}}tj
d�j�dd�dd�|D���d|�d�ddd�qZi}i}|D]#}t|�dkr�|\}	}
nt|�dkr�|\}	}
}|||	<nJ�|
||	<q�|��D]\}}
t�j||
�q���|�j|�dS)N�__dataclass_fields__r�z� is already a dataclass; ensure that base classes / decorator styles of establishing dataclasses are not being mixed. This can happen if a class that inherits from 'MappedAsDataclass', even indirectly, is been mapped with '@registry.mapped_as_dataclass'rKzk already defines a '__table__'. ORM Annotated Dataclasses do not support a pre-existing '__table__' elementrrGr�rrrMrzcs&|�jurd|jvr�|�|�dS)Nr\T)rqr�r�)rr�)rQ�warn_for_non_dc_attrsrPrR�_allow_dataclass_field:s

zT_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>._allow_dataclass_fieldcs.g|]\}}}t�|||�j�|tj���qSrP)r!�!_get_arguments_for_make_dataclassr�r�r2�NO_ARG)rr�annor�rcrPrRr/Hs���zH_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>.<listcomp>c	3sX�|]'\}\}}}}}}}�||�r)|�jvst�j|t�s||r$|n||fVqdSrO)r�r�r)	rr�raw_annor��mapped_anno�is_dcr�r�r�)r^rQrPrRr4Os.��

���
��zG_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>.<genexpr>zWhen transforming z to a dataclass, attribute(s) �, cs��|]}t|�VqdSrO�ri)rrrPrPrRr4w��z originates from superclass a, which is not a dataclass.  This usage is deprecated and will raise an error in SQLAlchemy 2.1.  When declaring SQLAlchemy Declarative Dataclasses, ensure that all mixin classes and other superclasses which include attributes are also a subclass of MappedAsDataclass.z2.0�dcmx��coder.�F)rrGr�rrrMrz)r�rqr�rr��collections�defaultdictr>rr�r��itemsr0�warn_deprecated�joinr�rK�_apply_dataclasses_to_any_class)rQr�r��
field_listr��non_dc_attrsr�defaults�itemr��tp�spec�k�vrP)r^rQr]rRrsb��

��'�
��
�



�z4_ClassScanMapperConfig._setup_dataclasses_transforms�klass�!Mapping[str, _AnnotationScanType]c	Cslt�|�}i}|��D](\}}t|||�r/t|||j|td�dddd�}|r.|\}}|||<q|||<q|S)NF��requiredrX�
expect_mapped)r0r;ror+r*rUr�)	rqr{r2�new_annor�rW�	extracted�inner�_rPrPrR�(_update_annotations_for_non_mapped_class�s(
�
�
z?_ClassScanMapperConfig._update_annotations_for_non_mapped_classrg�use_annotationsc
Cs�|�|�|d}|tjurtj}|r t|dd�}td|�|_nd}zBz||fidd�|��D���Wnt	t
fyR}ztjd|j
�d|�d�d	d
�|�d}~wwW|rc|dur^|`dS||_dSdS|rq|durn|`w||_w)NrorXr�cSs(i|]\}}|tjur|dkr||�qS)ro)r2r`)rryrzrPrPrRr�s
�zJ_ClassScanMapperConfig._apply_dataclasses_to_any_class.<locals>.<dictcomp>zAPython dataclasses error encountered when creating dataclass for z: zN. Please refer to Python dataclasses documentation for additional information.�dcterj)�_assert_dc_argumentsr2r`r�	dataclassr�rrXro�	TypeError�
ValueErrorrr�rH)rqr�r{r�ro�restored�exrPrPrRrr�sL

��
��������
�
z6_ClassScanMapperConfig._apply_dataclasses_to_any_class�	argumentscCsHhd�}t|��|�}|r"d�dd�t|�D��}t�d|�d���dS)N>rjrhrirkrnrmrlrorecss�|]}|�VqdSrOrP)r�argrPrPrRr4�s�z>_ClassScanMapperConfig._assert_dc_arguments.<locals>.<genexpr>zDataclass argument(s) z are not accepted)�set�
differencerq�sortedrrH)rqr��allowed�disallowed_args�msgrPrPrRr��s

��z+_ClassScanMapperConfig._assert_dc_argumentsr�rGr�r6r�r�Optional[bool]r�r�Optional[_CollectedAnnotation]c
Cs||jvr
|j|S|durdS|j}|j}|dur0t|tj�}|o.|o.|dup.t|t�}nd}d}t||j|j	|t
|�d||oD|d�}	|	durMdS|	\}
}|durzt|
�szt|
�D]}t
|ddd�rpt|j||j	dd�}t|t�ry|��}q]t|||
|||j	|�|j|<}
|
S)NFr}T)�
check_generic�check_for_plain_string)�include_generic)r�r�r�r�r�Fieldr$r*rqrUr�r9r7r8r-r#�found_in_pep593_annotatedr�)rQr�r�r�rr�r��allow_unmappedrXr�r�r��elem�carPrPrRrO�sj

��	�
��
��	z*_ClassScanMapperConfig._collect_annotationrr�cCs,t|tj�rt�d|�d|�d��dSdS)N�Attribute '�' on class z� appears to be a non-schema SQLAlchemy expression object; this won't be part of the declarative mapping. To map arbitrary expressions, use ``column_property()`` or a similar function such as ``deferred()``, ``query_expression()`` etc. )r�r1�
ColumnElementr0r�)rQrqrr�rPrPrRrQBs
��z0_ClassScanMapperConfig._warn_for_decl_attributes�attributes_for_classrrS�0Dict[str, Union[Column[Any], MappedColumn[Any]]]cCsX|j}|j}i}|j}|�D]�\}	}
}}|sJ|
durJt|||�rJ||	|
�r&q|�|	||d|
�}
|
dur6|
jn|
}
|
dur?t�}
|
||	<t||	|
�qt|
t	tf�r�||	|
�rWq|�|	||d|
�}
|
durg|
jn|
}
|	|vr�d|vr~t
|
dd�px|	|djvs�|
jr�|
jD]}|j
dur�|j
jdur�t�d��q�|
��||
<}|||	<t||	|�q|S)NTrKr�z�Columns with foreign keys to non-table-bound columns must be declared as @declared_attr callables on declarative mixin classes.  For dataclass field() objects, use a lambda:.)rqr�r�r+rOr�r)rKr�r3r�r��foreign_keys�
_table_columnr�rr��_copy)rQr�rrSr�rqr��locally_collected_attributesr�r�r�rWr�rZ�fk�copy_rPrPrRrEOsf	�
�

���

����

��
�z-_ClassScanMapperConfig._produce_column_copiesc
s�|j}|j}|j}|j}t|ddd�}|j}|p|j}t|j�}t	|�D�]:}	|	|vr,q$||	�t
��rE�jr?t�
d|j�t||	��nt�t�r_�j|ur_�j|	kr_t�j��t||	��t�t�r{t��dkr{t�dttf�r{t�
d|	�q$|r�t�tj�r�q$t�ttf�s�|�|	�|�||	��|s�t||	��q$|	dvr�t�d	|	�d
���t�t�r�t |	|j!�"����n�t�t#��r	|j$�"|	d�\}
}}}
}}}|dus�|
dus�|�rz��%||j&|||	||
||
�	Wnt'�y}z
t�(d|
�d
��|�d}~ww|�s	J�t�t��r[�j)�rG|�sGt�t*��r!gd�}ngd�}�fdd�|D�}t�(d|	�d|�dd�+t,dd�|D����d���t�t*t-f��s[|�|	�t||	��q$�||	<q$dS)Nr{Tr|z�Use of @declared_attr.cascading only applies to Declarative 'mixin' and 'abstract' classes.  Currently, this flag is ignored on mapped class %srrz�Ignoring declarative-like tuple value of attribute '%s': possibly a copy-and-paste error with a comma accidentally placed at the end of the line?)rZzAttribute name 'z-' is reserved when using the Declarative API.)NNNFNNNz7Could not resolve all types within mapped annotation: "zU".  Ensure all types are written correctly and are imported within the module in use.)rh�default_factoryri�default)rhr�rics(h|]}t�jd|���tjur|�qS)�dataclasses_)r��_attribute_optionsr2r`�r�a�r�rPrR�	<setcomp>Hs���zF_ClassScanMapperConfig._extract_mappable_attributes.<locals>.<setcomp>r�r�z# includes dataclasses argument(s): recsrfrOrgr�rPrPrRr4TrhzF_ClassScanMapperConfig._extract_mappable_attributes.<locals>.<genexpr>zF but class does not specify SQLAlchemy native dataclass configuration.).rqr�r�r-r~r�r�rzr�r>r�r�r0r�r�r�rr�rr rKrGr�r3r$rr�r"�poprQrr��_undefer_column_namer�r�r#r�r�r��	NameErrorrH�_has_dataclass_argumentsr&rqr�r%)rQrqr��	our_stuffr-�late_mappedr��expect_annotations_wo_mapped�look_for_dataclass_thingsryrWr�r�r�r�r�r��ne�argnames�argsrPr�rRr�s���
���


�����

�
�	���������
��

�	��


��z3_ClassScanMapperConfig._extract_mappable_attributesc
Cs2|j}|j}|j}t�t�}t|���D]c\}}t|t	�rV|j
}|r'|||<n||=|jD]'\}}	t|t�s>||j
�|�|�|�|	||<|durT||jkrT|||<q-qt|t�rw|j
dusbJ�||j
�|�|�|�||jkrw||=q|��D]\}
}t|�dkr�t�d|j|
d�t|��f�q|dS)NrzzOn class %r, Column object %r named directly multiple times, only one will be used: %s. Consider using orm.synonym insteadre)r�r�r�rmrnr�r>ror�r%�mapper_property_to_assign�columns_to_assignrr��addrr3r�r0r�r�rqr�)rQr�r�r��name_to_prop_keyrr��mp_to_assign�col�
sort_orderr��keysrPrPrRrnsF




��


�����z0_ClassScanMapperConfig._extract_declared_columnsNcs�|j}td|�}|j}|j}|j}|j}|j�t�|�}|j	dur�d|vr�|dur�t
|d�r:tttt
�|j��}	nt}	|dur�d}
i}|rht|t�rN|}nt|t�rht|dt�rf|dd�|d}
}n|}
|�d�}|rs||d<|�d	�}
|
r~d
|d<t|�fdd
�d�}|�d|	||�|�g|�|
�Ri|���}n(|dur�|j	r�|�d|�	��}n|j}|r�|D]}|j�|�s�t�d|j��q�||_dS)N�MappedClassProtocol[Any]rK�
__table_cls__rP���r�__autoload_with__�
autoload_with�__autoload__T�autoloadcs��|d�S)Nrr1)r��r�rPrR�<lambda>�sz5_ClassScanMapperConfig._setup_table.<locals>.<lambda>�rz8Can't add additional column %r when specifying __table__)rqrr�r�r�r�r�rr�r�r�rr4r0�unbound_method_to_callabler�r�r@rGr�r�r��_metadata_for_clsrKr��contains_columnrrHrr�)rQr�rqrBr�r�r�r�r��	table_clsr��table_kwr�r��sorted_columnsr�rPr�rRr	�s�




�




�����������
z#_ClassScanMapperConfig._setup_tabler��ClassManager[Any]rBcCs"t|jdd�}|dur
|S|jjS)NrZ)r�rqr�rZ)rQr��metarPrPrRr��sz(_ClassScanMapperConfig._metadata_for_clscCs�|j}|�dd�}|durAg}|jD]}t|�}|durqt|�r*||vr*|�|�q|r@t|�dkr<t�d||f��|d}nt	|t
�rI|j}||_|j
}d|vr]|jdur_d|_dSdSdS)Nr�rr�rrKT)rqr�r�r�rr�r�rr�r�r'r�r�r�r�r�)rQr�rqr�r�r�r�r�rPrPrRr�s6

����

�z/_ClassScanMapperConfig._setup_inheriting_mapperc

CsX|j}|j}|j}|j}|dur!|jdur!t|d�s!t�d|��|jr�t|j�}|dus/J�|j}|j	}|dur�|r@t�
d��|rUt|t�sUt�
d|j�d|j�d���|D]R}	|dus_J�|	j
|jvr�|j|	j
|	urnqWt�
d|	�d|j�d	|j|	j
�d
���|	jr�t�
d��tr�t|t�s�J�|�|	�|dur�||ur�|�|	�qWdSdSdS)N�__no_table__zwClass %r does not have a __table__ or __tablename__ specified and does not inherit from an existing table-mapped class.z?Can't place __table_args__ on an inherited class with no table.z9Can't declare columns on single-table-inherited subclass z
; superclass z is not mapped to a TablezColumn 'r�z! conflicts with existing column 'zs'.  If using Declarative, consider using the use_existing_column parameter of mapped_column() to resolve conflicts.zDCan't place primary key columns on an inherited class with no table.)r�rqr�r�r�r~rr�ryr�rHr�r4r�r�rH�primary_keyr�
append_column�_refresh_for_new_column)
rQr�r�rqr�r��inherited_mapper_or_config�inherited_table�inherited_persist_selectabler�rPrPrRr
st
���
�����
���
���z0_ClassScanMapperConfig._setup_inheriting_columnscs��j}�jr���}ni}|r|�|�d|vr#t|�}|�|d�dD]}||vr8||}�j�||�||<q%d|vrM�fdd�t�|d�D�|d<d|vrk|d}t|t	�r]|j
}|�jurkt�
d|d���jrs�j|d<�jr�|�dd	�s�t�jd	���j}d
|vr��fdd�|jD���jp�d
�|d
<}|�dd��jD��t|���D]"\}}	t|	tj�s�q�|�jvrЈj|}
t|
t�r�|	g|
j||<q�|��}||d<|�_dS)Nr�)�version_id_col�polymorphic_onr�csg|]	}�j�||��qSrP)r�r�)rrzrcrPrRr/~s��zD_ClassScanMapperConfig._prepare_mapper_arguments.<locals>.<listcomp>r�z:mapper inherits argument given for non-inheriting class %s�concreteF�exclude_propertiescsh|]
}|�jvr|j�qSrP)�_columntopropertyr�rr�)�inherited_mapperrPrRr��s

�zC_ClassScanMapperConfig._prepare_mapper_arguments.<locals>.<setcomp>rPcSsg|]}|j�qSrPr�r�rPrPrRr/�s)r�r�rFr@r�r�r0�to_listr�r'r�r�rr�r,r�r��unionr��difference_updater�r>ror1r��_propsr(�columns�copyr�)rQr�r�r�ryrz�inherits_argr�r�r��p�result_mapper_argsrP)r�rQrR�_prepare_mapper_argumentsgsj

�

�

��

�
��



�
z0_ClassScanMapperConfig._prepare_mapper_argumentsr�cCsP|�|�t|jd�rtdt�|jj��}nt}|�d||j|j	fi|j
���S)N�__mapper_cls__zType[Mapper[Any]]rJ)r�r�rqrr0r�r�r'r�r�r�r�rPrPrRr��s
���z_ClassScanMapperConfig.map)
r�r=r�r�r�r<r�r�r�r\rf)rqr�rMr)rqrrrMr*)r{r�rMr|)r�rgr{r�r�r|rMrb)r�rgrMrb)r�rGr�r6r�rrrr�r�rrMr�)rqrrrrGr�rrMrb)
r�r*rrrSrzr�rrrMr�rO)r�r�rMrb)r�r�rMrBr�r�)"rHrUrVr��is_deferredrXr�rr)r-�re�compiler.r?rrr�r�rrr�rOrQrErrr	r�rr
r�r0r�r�r�rPrPr�rRr��sh
	
M
L


D
0x4

J

Z
F;
N

!
HQr��field_metadatar�rcCs2tjj}||}t|�rt||j�s|�|�S|SrO)r0r�r��callabler�r?)r�r�decl_apir�rPrPrRr9�s

r9cs�eZdZUded<dZe��Zded<d$d
d�Ze	d%d
d��Z
e
jd&dd��Z
ed'dd��Z
ed(dd��Zed)dd��Zed*dd��Ze	d+d,dd ��Zejfd-�fd"d#�
Z�ZS).ru�weakref.ref[Type[Any]]�_clsTz?util.OrderedDict[weakref.ref[Type[Any]], _DeferredMapperConfig]�_configsr�r\rMrbcCrNrOrPr�rPrPrRr��sz$_DeferredMapperConfig._early_mappingrrcCs|��SrO)r�rcrPrPrRrq�sz_DeferredMapperConfig.clsr�cCs t�||j�|_||j|j<dSrO)�weakref�ref�_remove_config_clsr�r�)rQr�rPrPrRrq�sr�cCs|j�|d�dSrO)r�r�)rqr�rPrPrRr��sz(_DeferredMapperConfig._remove_config_clsrzcCst|t�ot�|�|jvSrO)r�r�r�r�r��rqr�rPrPrRrv�sz_DeferredMapperConfig.has_clsrcCs.t|d�r	|��tj|dt�|��d�d��)N�_sa_raise_deferred_configr�zG has a deferred mapping on it.  It is not yet usable as a mapped class.)r�)r�r��orm_exc�UnmappedClassError�_safe_cls_namer�rPrPrR�raise_unmapped_for_cls�s
�z,_DeferredMapperConfig.raise_unmapped_for_clscCs|jt�|�SrO)r�r�r�r�rPrPrRrwsz$_DeferredMapperConfig.config_for_cls�base_cls�sort�List[_DeferredMapperConfig]csr�fdd�dd�|j��D�D�}|s|Sdd�|D��g}�D]�|���fdd��jD��q tt�||��S)Ncs&g|]\}}|durt|��r|�qSrO)r�)r�mr�)rrPrRr/
s
�z:_DeferredMapperConfig.classes_for_base.<locals>.<listcomp>cSsg|]}||jf�qSrPrx�rrrPrPrRr/scSr7rPrxrrPrPrRrsz:_DeferredMapperConfig.classes_for_base.<locals>.<dictcomp>c3s(�|]}|�vr�|��fVqdSrOrP)rr)�all_m_by_cls�m_clsrPrRr4s���z9_DeferredMapperConfig.classes_for_base.<locals>.<genexpr>)r��values�extendr�r>r5r)rqrr�classes_for_base�tuplesrP)rrrrRr	s
�
�z&_DeferredMapperConfig.classes_for_baser�cs|j�|jd�t��|�SrO)r�r�r�r�r�r�r�rPrRr�!sz_DeferredMapperConfig.mapr�)rMrr)r�rrrMrb)r�r�rMrb)r�rrrMrz)r�rrrMr)r�rrrMru)T)rrrrrzrMrr�)rHrUrVrXr�r0r�r�r��propertyrq�setterr�r�rvrrwrr�r�r�rPrPr�rRru�s,

�
�rurr��MapperProperty[Any]rbcCs8d|jvr�td|�}ddd�}t|t�r+t||�||�j|dd	�|j�||�d
St|t�r_|j	}|j
D]\}}t||�||�j|dd	�|sQ|j�||�q6|r]|j�||�d
Sd
St|t�rm|j�||�d
St|t�r�|j
|kr�t|j
�}|j�||�d
St�|||�|j��d
St�|||�d
S)z�add an attribute to an existing declarative class.

    This runs through the logic to determine MapperProperty,
    adds it to the Mapper, adds a column to the mapped Table, etc.

    rJr��mcrMr4cSs&t|jt�r	|jSt�d|j�d���)Nz+Cannot add a new attribute to mapped class z) because it's not mapped against a table.)r�rKr4rr�rH)rrPrPrR�_table_or_raise3s
�z'_add_attribute.<locals>._table_or_raiseT)�replace_existingN)rr�rMr4)r�rr�r3r�r�rJ�add_propertyr%r�r�r&rrr r��__setattr__�_expire_memoizations)rqrr��
mapped_clsr�mpr�r�rPrPrR�_add_attribute&s<





�

���

rcCsvd|jvr3||jvr3td|�jjs3|j|}t|ttttf�r#t	d��t
�||�td|�j��dSt
�||�dS)NrJr�z<Can't un-map individual mapped attributes on a mapped class.)
r�rrJ�_dispose_calledr�r3r%r&rr�r��__delattr__r)rqrr�rPrPrR�_del_attributeZs(

��
���rrQ�kwargscKsBt|�}|D]}t||�std||jf��t||||�qdS)a=A simple constructor that allows initialization from kwargs.

    Sets attributes on the constructed instance using the names and
    values in ``kwargs``.

    Only keys that are present as
    attributes of the instance's class are allowed. These could be,
    for example, any mapped columns or relationships.
    z(%r is an invalid keyword argument for %sN)r�r�r�rHrK)rQrr�ryrPrPrR�_declarative_constructorrs

��rr��column�Column[Any]cCs(|jdur||_|jdur||_dSdSrO)rr�)rrrPrPrRr��s



�r�)rqrrrMrs)rqrrrMrz)rqrrrMr�)F)rqrrr�rGr}rzrMr�)rqr�rMr�)r�r=rqrrr�r<rMr�)
r�r=rqr�r�r�r�r\rMrI)r�rrMrz)r�rr�rGrqr�rMrz)r�r�rrGrMr)rqrrrrGr�rrMrb)rqrrrrGrMrb)rQrrrrMrb)rrGrrrMrb)rrW�
__future__rrmrr��typingrrrrrrr	r
rrr
rrrrrr��rrrr�rr�_typingrrrrr�rr�descriptor_propsrr �
interfacesr!r"r#r$r%r&�mapperr'r�r(r)r0r*r+r,r-r/�sqlr1�sql.baser2�
sql.schemar3r4r5�util.typingr6r7r8r9r:r;r<r=r>r�r?r@�sql.elementsrArB�sql.selectablerCrDrGr\�_TableArgsTyperFrYrgryrr�r~r�r�r��preload_moduler�r�r�r�r�r�r9rurrrrHr�rPrPrPrR�<module>s�


�
'



Z>

M
4

@ Telegram