o
    Š)fÁ> ã                   @  s   d Z ddlmZ ddlZddlZddlZddlmZ ddlmZ ddlm	Z	 ddlm
Z
 ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z  ddlm!Z! ddlm"Z" ddlm#Z# ddl$m%Z% ddl$m&Z& dd l'm(Z( dd!l'm)Z) dd"l*m+Z+ dd#l*m,Z, dd$l*m-Z- dd%l*m.Z. dd&l*m/Z/ dd'l*m0Z0 dd(l1m2Z2 dd)l3m4Z4 dd*l3m5Z5 dd+l6m7Z7 dd,l6m8Z8 dd-l6m9Z9 dd.l6m:Z: d/d0lm;Z; d/dlmZ d/d1lm6Z6 d/d2l<m=Z= d/d3l>m?Z? d/d4l@mAZA d/d5l@mBZB d/d6l6mCZC d/d7lDmEZE d/d8lDmFZF d/d9lDmGZG d/d:lDmHZH d/d;lDmIZI d/d<lDmJZJ e�r›dd=lmKZK dd>lmLZL dd?l$mMZM dd@lNmOZO ddAlmPZP d/dBlQmRZR d/dCl@mSZS d/dDlTmUZU edEedF�ZVeeWef ZXeeedGf e
eWef f ZYG dHdI„ dIeHe  ƒZZG dJdK„ dKeZe  eHƒZ[G dLdM„ dMeIƒ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„ZfG d{d|„ d|ƒZgG d}d~„ d~egƒZhG dd€„ d€eƒZiG d�d‚„ d‚egƒZje6 dds¡d¥d†d‡„ƒZkG dˆd‰„ d‰ejƒZld¦dŽd�„Zmd§d�d‘„Znd¨d”d•„Zod–eo_pd©d™dš„ZqdS )ª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)Ú
is_fwd_ref)Ú
is_literal)ÚProtocol)Ú	TypedDict)Útyping_get_args)Ú
_ClassDict)Ú_RegistryType)ÚMapped)Údeclared_attr)ÚClassManager)ÚNamedColumn)ÚMetaData)Ú
FromClauseÚ_T)Úbound.c                   @  s4   e Zd ZU dZded< ded< ded< ddd„ZdS )Ú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   Úreturnr   c                 K  ó   d S ©N© )ÚselfrL   rP   rP   úU/var/www/html/flask-app/venv/lib/python3.12/site-packages/sqlalchemy/orm/decl_base.pyÚ__call__e   ó    zMappedClassProtocol.__call__N)rL   r   rM   r   )rH   Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__rS   rP   rP   rP   rR   rF   Z   s   
 rF   c                   @  sN   e Zd ZU dZded< ded< ded< ded	< d
ed< ddd„Zddd„ZdS )Ú_DeclMappedClassProtocolz:Internal more detailed version of ``MappedClassProtocol``.rB   ÚmetadatarG   Ú__tablename__Ú_MapperKwArgsÚ__mapper_args__úOptional[_TableArgsType]Ú__table_args__úOptional[_DataclassArguments]Ú_sa_apply_dc_transformsrM   ÚNonec                 C  rN   rO   rP   ©rQ   rP   rP   rR   Ú__declare_first__q   rT   z*_DeclMappedClassProtocol.__declare_first__c                 C  rN   rO   rP   rc   rP   rP   rR   Ú__declare_last__s   rT   z)_DeclMappedClassProtocol.__declare_last__N©rM   rb   )rH   rU   rV   rW   rX   rd   re   rP   rP   rP   rR   rY   h   s   
 
rY   c                   @  sN   e Zd ZU ded< ded< ded< ded< ded< ded< ded< d	ed
< dS )Ú_DataclassArgumentszUnion[_NoArg, bool]ÚinitÚreprÚeqÚorderÚunsafe_hashÚ
match_argsÚkw_onlyz'Union[_NoArg, Callable[..., Type[Any]]]Údataclass_callableN©rH   rU   rV   rX   rP   rP   rP   rR   rg   v   s   
 rg   Úclsú	Type[Any]rM   ú3Optional[Union[_DeferredMapperConfig, Mapper[Any]]]c                 C  s,   t  | ¡r
t  | ¡S t| ƒrt| dd�S d S )NF)Ú	configure)Ú_DeferredMapperConfigÚhas_clsÚconfig_for_clsr   r,   ©rq   rP   rP   rR   Ú_declared_mapping_info�   s
   

ry   Úboolc                 C  s*   t  | ¡rt| ddd� S t| ƒrdS dS )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)ru   rv   Ú_get_immediate_cls_attrr   rx   rP   rP   rR   Ú_is_supercls_for_inheritsŽ   s   
ÿr   úOptional[Type[Any]]c                 C  sX   | t u rd S | j dd¡r!| jD ]}t|ƒ}|d ur|  S qd S t| ƒ}|r*|jS | S )NÚ__abstract__F)ÚobjectÚ__dict__ÚgetÚ	__bases__Ú"_resolve_for_abstract_or_classicalÚ_dive_for_cls_managerÚclass_)rq   Úbase_ÚsupÚ
clsmanagerrP   rP   rR   r†   ¤   s   
ÿr†   FÚattrnamerG   r}   úOptional[Any]c                 C  sˆ   |dksJ ‚t | tƒsdS || jv rt| |ƒS | jdd… D ]#}t|ƒdu}||jv rA|| u s:|r7|| jv rAn	 |sAt||ƒ  S qdS )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…   )rq   rŒ   r}   ÚbaseÚ_is_classical_inheritsrP   rP   rR   r~   º   s"   



þÿ€r~   úType[_O]úOptional[ClassManager[_O]]c                 C  s&   | j D ]}t |¡}|r|  S qd S rO   )r�   r   Úopt_manager_of_class)rq   r‘   ÚmanagerrP   rP   rR   r‡   á   s   
ÿÿr‡   Úregistryr=   Údict_r<   úOptional[_MapperConfig]c                 C  s   t  | ||d i ¡S rO   )Ú_MapperConfigÚsetup_mapping)r—   rq   r˜   rP   rP   rR   Ú_as_declarativeï   s   rœ   ÚtableúOptional[FromClause]Ú	mapper_kwr\   rI   c                 C  s   t | |||ƒ td|ƒjS )NzMappedClassProtocol[_O])Ú_ImperativeMapperConfigr   rJ   )r—   rq   r�   rŸ   rP   rP   rR   Ú_mapper÷   s   r¡   zsqlalchemy.orm.decl_apiÚobjr   c                 C  s   t jjj}t| |t jfƒS rO   )r0   Ú	preloadedÚorm_decl_apiÚ_declared_attr_commonÚ
isinstanceÚclassproperty)r¢   r¥   rP   rP   rR   Ú_is_declarative_props  s   
r¨   Únamec                 C  s.   t | ƒrt| ddƒrt d||f ¡ dS dS )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©   rq   rP   rP   rR   Ú_check_declared_props_nocascade  s   þÿr¬   c                   @  sj   e Zd ZU dZded< ded< ded< ded	< ed'dd„ƒZd(dd„Zd)dd„Zd*d+d!d"„Z	d,d$d%„Z
d&S )-rš   )rq   Ú	classnameÚ
propertiesÚdeclared_attr_regÚ__weakref__rr   rq   rG   r­   z_util.OrderedDict[str, Union[Sequence[NamedColumn[Any]], NamedColumn[Any], MapperProperty[Any]]]r®   zDict[declared_attr[Any], Any]r¯   r—   r=   Úcls_r“   r˜   r<   r�   rž   rŸ   r\   rM   r™   c                 C  sx   t  | ¡}|r|j|u rt d| ›d�¡‚|j dd¡rd S t|ddd�p)t|dƒ}|r4t	|||||ƒS t
|||||ƒS )	NúClass z, already has been instrumented declarativelyr�   Fr{   Tr|   Ú_sa_decl_prepare)r   r•   rˆ   r   ÚInvalidRequestErrorrƒ   r„   r~   Úhasattrru   Ú_ClassScanMapperConfig)rq   r—   r±   r˜   r�   rŸ   r–   Ú	defer_maprP   rP   rR   r›   *  s&   
	
ÿÿþ
ÿ
ÿz_MapperConfig.setup_mappingc                 C  sz   t  |td¡| _|j| _t  ¡ | _i | _| 	dd¡s(t
j| jd|| |jd� d S t | j¡}|r3|js;t d| j ¡‚d S )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Útyperq   rH   r­   ÚOrderedDictr®   r¯   r„   r   Úregister_classÚconstructorr   r•   Ú	is_mappedr   r´   )rQ   r—   r±   rŸ   r–   rP   rP   rR   Ú__init__I  s(   

û
þÿÿz_MapperConfig.__init__rŒ   ÚvaluerD   c                 C  s   t  | j¡}| ||¡ |S rO   )r   Úmanager_of_classrq   Úinstall_member)rQ   rŒ   rÃ   r–   rP   rP   rR   Úset_cls_attributee  s   z_MapperConfig.set_cls_attribute.úMapper[Any]c                 C  s   t ƒ ‚rO   )ÚNotImplementedError©rQ   rŸ   rP   rP   rR   Úmapj  s   z_MapperConfig.maprb   c                 C  s   |   |¡ d S rO   )rÊ   rÉ   rP   rP   rR   Ú_early_mappingm  s   z_MapperConfig._early_mappingN)r—   r=   r±   r“   r˜   r<   r�   rž   rŸ   r\   rM   r™   )r—   r=   r±   rr   rŸ   r\   )rŒ   rG   rÃ   rD   rM   rD   ).©rŸ   r\   rM   rÇ   ©rŸ   r\   rM   rb   )rH   rU   rV   Ú	__slots__rX   Úclassmethodr›   rÂ   rÆ   rÊ   rË   rP   rP   rP   rR   rš     s   
 

rš   c                      s<   e Zd ZdZd‡ fd
d„Zejfddd„Zddd„Z‡  Z	S )r    )Úlocal_tableÚinheritsr—   r=   r±   r“   r�   rž   rŸ   r\   c                   s~   t ƒ  |||¡ |  d|¡| _tj�# | dd¡s#t | j	| j
|j¡ |  |¡ |  |¡ W d   ƒ d S 1 s8w   Y  d S )NrK   r¸   F)ÚsuperrÂ   rÆ   rÐ   r   Ú_CONFIGURE_MUTEXr„   r   Ú	add_classr­   rq   Ú_class_registryÚ_setup_inheritancerË   )rQ   r—   r±   r�   rŸ   ©Ú	__class__rP   rR   rÂ   t  s   ÿ
"øz _ImperativeMapperConfig.__init__rM   rÇ   c                 C  s"   t }|  d|| j| jfi |¤Ž¡S )NrJ   )r'   rÆ   rq   rÐ   ©rQ   rŸ   Ú
mapper_clsrP   rP   rR   rÊ   ‰  s
   þz_ImperativeMapperConfig.maprb   c                 C  sœ   | j }| dd ¡}|d u rAg }|jD ]}t|ƒ}|d u rqt|ƒr*||vr*| |¡ q|r@t|ƒdkr<t d||f ¡‚|d }nt	|t
ƒrI|j}|| _d S )NrÑ   r   ú&Class %s has multiple mapped bases: %rr   )rq   r„   r…   r†   r   ÚappendÚlenr   r´   r¦   r'   rˆ   rÑ   )rQ   rŸ   rq   rÑ   Úinherits_searchr‰   ÚcrP   rP   rR   rÖ   ‘  s.   

€ÿÿ€

z*_ImperativeMapperConfig._setup_inheritance)r—   r=   r±   r“   r�   rž   rŸ   r\   rÌ   rÍ   )
rH   rU   rV   rÎ   rÂ   r0   Ú
EMPTY_DICTrÊ   rÖ   Ú__classcell__rP   rP   r×   rR   r    q  s
    r    c                   @  sF   e Zd ZU ded< ded< ded< ded< d	ed
< ded< ded< dS )Ú_CollectedAnnotationr6   Úraw_annotationzOptional[Type[Mapped[Any]]]Úmapped_containerzUnion[Type[Any], str]Úextracted_mapped_annotationrz   Úis_dataclassr   Ú
attr_valuerG   Úoriginating_modulerr   Úoriginating_classNrp   rP   rP   rP   rR   râ   ¯  s   
 râ   c                      s¨  e Zd ZU dZdZded< ded< ded< d	ed
< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded< ded < ded!< d"ed#< 	 ded$< 	 du‡ fd+d,„Zdvd/d0„Zdwd3d4„Zh d5£Z	e
 d6¡Zdxd9d:„Zdvd;d<„Zdvd=d>„ZedydAdB„ƒZedzdEdF„ƒZed{dHdI„ƒZd|dTdU„Zd}dXdY„Zd~d^d_„Zdvd`da„Zdvdbdc„Zdd€dedf„Zd�djdk„Zd‚dldm„Zd‚dndo„Zd‚dpdq„Zejfdƒ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_fnrÑ   ÚsingleÚallow_dataclass_fieldsÚdataclass_setup_argumentsÚis_dataclass_prior_to_mappingÚallow_unmapped_annotationsFr=   r—   r<   rê   zDict[str, _CollectedAnnotation]rì   úDict[str, Any]rë   rž   rÐ   rí   zutil.OrderedSet[Column[Any]]rî   zDict[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Ñ   rz   rõ   rø   rù   r`   r÷   rö   r±   r“   r˜   r�   rŸ   r\   c           	        sV  |rt  |¡nt j| _tƒ  |||¡ || _d | _i | _i | _	t  
¡ | _i | _i | _d| _t| jdd ƒ | _}t| jddƒpBt| jƒ| _t |¡ | _}t|dƒ}|rU|r\|r\t d¡‚t|o`|ƒ| _|  ¡  |  ¡  |  ¡  tj�/ t  !| j"| j|j#¡ |  $|¡ |  %¡  |  &¡  |  '|¡ |  (|¡ |  )|¡ W d   ƒ d S 1 s¤w   Y  d S )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�   rq   r÷   rz   rù   Údataclassesræ   rø   r~   r   r´   rö   Ú_setup_declared_eventsÚ_scan_attributesÚ_setup_dataclasses_transformsr   rÓ   r   rÔ   r­   rÕ   Ú_setup_inheriting_mapperÚ_extract_mappable_attributesÚ_extract_declared_columnsÚ_setup_tableÚ_setup_inheriting_columnsrË   )	rQ   r—   r±   r˜   r�   rŸ   ÚdcaÚcldÚsdkr×   rP   rR   rÂ   ø  sT   ÿ

ÿÿþ
ÿ
ÿ	ÿ


"ñz_ClassScanMapperConfig.__init__rM   rb   c                   sT   t ˆ jdƒrt td¡d‡ fdd„ƒ}t ˆ jdƒr(t td¡d‡ fd	d
„ƒ}d S d S )Nre   Úafter_configuredrM   rb   c                     ó   t dˆ jƒ ¡  d S ©Nú_DeclMappedClassProtocol[Any])r   rq   re   rP   rc   rP   rR   r  H  ó   ÿ
zG_ClassScanMapperConfig._setup_declared_events.<locals>.after_configuredrd   Úbefore_configuredc                     r  r  )r   rq   rd   rP   rc   rP   rR   r  P  r  zH_ClassScanMapperConfig._setup_declared_events.<locals>.before_configuredrf   )r~   rq   r/   Úlistens_forr'   )rQ   r  r  rP   rc   rR   r  E  s   

ýz-_ClassScanMapperConfig._setup_declared_eventsrq   úCallable[[str, Any], bool]c                   sz   | j r	tˆdƒ‰nd‰ˆsd‡fd	d
„}|S ‡fdd„t ˆ¡D ƒ‰‡fdd„t ˆ¡D ƒ‰tƒ ‰ d‡ ‡‡‡fdd
„}|S )z‘Produce a function that checks if a class has overridden an
        attribute, taking SQLAlchemy-enabled dataclass fields into account.

        rý   NÚkeyrG   r¢   r   rM   rz   c                   s   t ˆ | |ƒ|uS rO   )r�   )r  r¢   rx   rP   rR   Úattribute_is_overriddeng  s   zR_ClassScanMapperConfig._cls_attr_override_checker.<locals>.attribute_is_overriddenc                   ó$   i | ]}ˆ |j v r|j|j ˆ  “qS rP   ©rZ   r©   ©Ú.0Úf©Úsa_dataclass_metadata_keyrP   rR   Ú
<dictcomp>k  ó
    
þzE_ClassScanMapperConfig._cls_attr_override_checker.<locals>.<dictcomp>c                   r  rP   r  r  r  rP   rR   r  p  r  c                   s–   t |ƒr|j}ˆ | ˆ ¡}t |ƒr|j}||u rdS |ˆ ur dS ˆ | ˆ ¡}tˆ| |ƒ}||u r2dS |ˆ ur=t|tƒr=dS ||u rCdS |ˆ urIdS dS )NFT)r¨   Úfgetr„   r�   r¦   r   )r  r¢   ÚretÚ	all_field)ÚabsentÚall_datacls_fieldsrq   Úlocal_datacls_fieldsrP   rR   r  x  s,   
ÿ)r  rG   r¢   r   rM   rz   )rö   r~   r0   Údataclass_fieldsÚlocal_dataclass_fieldsr‚   )rQ   rq   r  rP   )r"  r#  rq   r$  r  rR   Ú_cls_attr_override_checkerV  s"   ÿ9
Ëþ
þ(z1_ClassScanMapperConfig._cls_attr_override_checker>   rK   r[   r_   r]   z^(?:_sa_|__)rr   ú2Callable[[], Iterable[Tuple[str, Any, Any, bool]]]c                   s¦   t  |¡‰t|ƒ‰| j‰ | j‰‡ ‡fdd„t  tˆƒtˆƒ¡D ƒ‰| jr*t|dƒ‰nd‰ˆs9d‡‡‡fdd„}|S d	d
„ t  	|¡D ƒ‰ˆ‰d‡‡‡‡‡‡fdd„}|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.

        c                   s"   g | ]}ˆ  |¡r|ˆ v r|‘qS rP   )Úmatch)r  Ún)Ú_include_dundersÚ_match_exclude_dundersrP   rR   Ú
<listcomp>º  s    ûüz=_ClassScanMapperConfig._cls_attr_resolver.<locals>.<listcomp>rý   NrM   ú$Iterable[Tuple[str, Any, Any, bool]]c                     s   ‡ ‡fdd„ˆD ƒS )Nc                 3  s(   � | ]}|ˆ  |¡ˆ   |¡d fV  qdS )FN©r„   )r  r©   )Úcls_annotationsÚcls_varsrP   rR   Ú	<genexpr>Î  s   € ûü
ÿz`_ClassScanMapperConfig._cls_attr_resolver.<locals>.local_attributes_for_class.<locals>.<genexpr>rP   rP   )r0  r1  ÚnamesrP   rR   Úlocal_attributes_for_classË  s   ùzM_ClassScanMapperConfig._cls_attr_resolver.<locals>.local_attributes_for_classc                 S  ó   i | ]}|j |“qS rP   )r©   )r  ÚfieldrP   rP   rR   r  Ù  s    ÿz=_ClassScanMapperConfig._cls_attr_resolver.<locals>.<dictcomp>c                  3  sf   � ˆD ]-} ˆ  | d ¡}|r#ˆ|jv r#|jt|jˆƒˆ   |j¡dfV  q| ˆ  | ¡ˆ   | ¡dfV  qd S )NTF)r„   rZ   r©   Ú_as_dc_declaredattr)r©   r6  )r0  r1  r%  Úfixed_sa_dataclass_metadata_keyr3  r  rP   rR   r4  ß  s   €ÿþÿþù)rM   r.  )
r0   Úget_annotationsÚvarsr+  r,  Úmerge_lists_w_orderingÚliströ   r~   r&  )rQ   rq   r4  rP   )r+  r,  r0  r1  r%  r8  r3  r  rR   Ú_cls_attr_resolver«  s.   
ÿþÿ"ìÿz)_ClassScanMapperConfig._cls_attr_resolverc              	     s<  | j }td|ƒ‰ | j}| j}| j}| j}d }d  }}d }	d|v }
|  | j ¡}g }|jD ])}||uo4t|ƒ}|  	|¡}|sI||urI|  
|||
|¡}ni }| ||||f¡ q+|D �]²\}}}}| |¡ |ƒ D �]¢\}}}}||v rÉ|dkr‹t|||ƒ}|sŠ|r�|rŠd‡ fdd„}|}qf|dkrŸt|||ƒ}|	sž|r›|ržˆ j}	qf|d	krÈt|||ƒ}|sÇ|r¯|rÇˆ j}t|tttd ƒfƒsÁt d
¡‚||urÇd}qfqf|rßt|ƒrÞ|jsÞt d|j|||f ¡ qf||u�r�t|ttfƒrìqft|tƒröt d¡‚t|ƒ�r}|d u�sJ ‚|j�r)||v �rt d||f ¡ |  ||¡ ||<  ||< }t!|||ƒ n6|�r=t"||d ƒ}t|t#ƒ�s<| $¡ }nt"||ƒ}t|t#ƒ�rWt%|ƒ�rWt|j&tƒ�sW|j'}| ||< ||< t|ttfƒ�rq|j(d u �rq|j)|_(|  *|| +¡ |d|¡ qft,|||ƒ�r•|
�s”||v �s”||d ƒ�s”J ‚qf|  -|||¡ qf|�rË||v�s¬|| |u�rË|||ƒ�r´J ‚t|ƒ�r½| $¡ }|||< |  *|||d|¡ qf|  *|||d |¡}|d u�oÝ|j.d u}|d u�ræ|j/n|}|d u �r |
�s |�r |d u�rú|ntƒ ||< qf||v �r	|||< qfqW|�r|	�sd }|| _0|	| _1|| _2d S )Nr  rK   r]   rM   rú   c                     s
   t ˆ jƒS rO   )Údictr]   rP   ©Úcls_as_DeclrP   rR   Ú_mapper_args_fn@  s   
z@_ClassScanMapperConfig._scan_attributes.<locals>._mapper_args_fnr[   r_   z3__table_args__ value must be a tuple, dict, or NoneTz‚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; skippingF)rM   rú   )3rq   r   rê   rë   rð   r+  r'  r�   r   r=  Ú_produce_column_copiesrÜ   Úupdater¬   r[   r_   r¦   Útupler>  r½   r   ÚArgumentErrorr¨   Ú_quietr0   r«   rH   r3   r)   r&   r´   rª   Ú__get__Úsetattrr�   r   r  r   Úoriginal_propertyÚ
descriptorÚdocrW   Ú_collect_annotationÚ_collect_return_annotationr+   Ú_warn_for_decl_attributesrä   rç   rñ   rò   rô   )rQ   rq   rê   rë   rð   r+  rô   rñ   Úinherited_table_argsrò   Úfixed_tabler  Úbasesr‘   Úclass_mappedr4  Úlocally_collected_columnsr©   r¢   Ú
annotationÚis_dataclass_fieldÚ
check_declrA  r   Úcollected_annotationrÁ   Úgenerated_objrP   r?  rR   r  ï  sb  


üüÿû
ûÿÿÿ	€ÿ€ÿÿÿ€üÿ

ÿ

ýÿ
þ€
ÿþÿýÿÿû
ÿ


ÿ
ÿ
þ
ÿý
ÿý
€ �­ Y
z'_ClassScanMapperConfig._scan_attributesc              	     s\  ˆj }|sd S dˆjjv rt dˆj› d�¡‚t t¡‰d‡‡fd
d„‰ t 	ˆj¡}|d us0J ‚‡fdd„‡ ‡fdd„ˆj
 ¡ D ƒD ƒ}ˆrjˆ ¡ D ]\}}tjdˆj› dd dd„ |D ƒ¡› d|› d�ddd� qJi }i }|D ]#}t|ƒdkr}|\}	}
nt|ƒdkr�|\}	}
}|||	< nJ ‚|
||	< qp| ¡ D ]\}}tˆj||ƒ q˜ˆ |ˆj|¡ d S )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'r  rG   ré   rr   rM   rz   c                   s&   |ˆ j urd|jvrˆ|  | ¡ dS )NrY  T)rq   rƒ   rÜ   )r  ré   )rQ   Úwarn_for_non_dc_attrsrP   rR   Ú_allow_dataclass_field  s   

zT_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>._allow_dataclass_fieldc                   s.   g | ]\}}}t  |||ˆ j |tj¡¡‘qS rP   )r!   Ú!_get_arguments_for_make_dataclassrë   r„   r2   ÚNO_ARG)r  r  Úannorä   rc   rP   rR   r-  +  s    úüÿzH_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>.<listcomp>c           	      3  sX   � | ]'\}\}}}}}}}ˆ ||ƒr)|ˆj vstˆj | tƒs||r$|n||fV  qd S rO   )rë   r¦   r   )	r  r  Úraw_annorä   Úmapped_annoÚis_dcrç   rè   ré   )r[  rQ   rP   rR   r2  2  s.   € ñ

ÿøñ
ýïzG_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>.<genexpr>zWhen transforming z to a dataclass, attribute(s) ú, c                 s  ó   � | ]}t |ƒV  qd S rO   ©ri   )r  r  rP   rP   rR   r2  Z  ó   € 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.z2.0Údcmx©Úcoder.   é   F)r  rG   ré   rr   rM   rz   )r÷   rq   rƒ   r   r´   ÚcollectionsÚdefaultdictr<  r   rÄ   rì   Úitemsr0   Úwarn_deprecatedÚjoinrÝ   rH  Ú_apply_dataclasses_to_any_class)rQ   r÷   r–   Ú
field_listré   Únon_dc_attrsr   ÚdefaultsÚitemr©   ÚtpÚspecÚkÚvrP   )r[  rQ   rZ  rR   r    sZ   ÿ
	
òù'ý
þü
ô



ÿz4_ClassScanMapperConfig._setup_dataclasses_transformsÚklassú!Mapping[str, _AnnotationScanType]c           	      C  sl   t  |¡}i }| ¡ D ](\}}t|||ƒr/t|||j|td ƒdddd�}|r.|\}}|||< q|||< q|S )NF©ÚrequiredrU  Úexpect_mapped)r0   r9  rl  r+   r*   rU   r½   )	rq   rx  r0  Únew_annor©   rT  Ú	extractedÚinnerÚ_rP   rP   rR   Ú(_update_annotations_for_non_mapped_classy  s(   
ø
€
z?_ClassScanMapperConfig._update_annotations_for_non_mapped_classrg   Úuse_annotationsc              
   C  sä   |   |¡ |d }|tju rtj}|r t|dd ƒ}td|ƒ|_nd }zBz||fi dd„ | ¡ D ƒ¤Ž W n t	t
fyR } ztjd|j›d|›d�d	d
�|‚d }~ww W |rc|d u r^|`d S ||_d S d S |rq|d u rn|`w ||_w )Nro   rX   rú   c                 S  s(   i | ]\}}|t jur|d kr||“qS )ro   )r2   r]  )r  rv  rw  rP   rP   rR   r  ¯  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.Údcterg  )Ú_assert_dc_argumentsr2   r]  r   Ú	dataclassr�   r   rX   rl  Ú	TypeErrorÚ
ValueErrorr   r´   rH   )rq   r÷   rx  r‚  ro   ÚrestoredÚexrP   rP   rR   ro  “  sL   

ÿþ
þÿþûú€ÿø
ü
z6_ClassScanMapperConfig._apply_dataclasses_to_any_classÚ	argumentsc                 C  sH   h d£}t |ƒ |¡}|r"d dd„ t|ƒD ƒ¡}t d|› d�¡‚d S )N>   rj   rh   ri   rk   rn   rm   rl   ro   rb  c                 s  s   � | ]}|›V  qd S rO   rP   )r  ÚargrP   rP   rR   r2  Ö  s   € z>_ClassScanMapperConfig._assert_dc_arguments.<locals>.<genexpr>zDataclass argument(s) z are not accepted)ÚsetÚ
differencern  Úsortedr   rE  )rq   rŠ  ÚallowedÚdisallowed_argsÚmsgrP   rP   rR   r„  È  s   

ÿþz+_ClassScanMapperConfig._assert_dc_argumentsr©   rG   rã   r6   ré   r|  úOptional[bool]rç   r   úOptional[_CollectedAnnotation]c              
   C  s   || j v r
| j | S |d u rd S | j}| j}|d u r0t|tjƒ}| o.| o.|d u p.t|tƒ}nd}d}t|| j|j	|t
|ƒd||oD| d�}	|	d u rMd S |	\}
}|d u r~t|
ƒs~t|
ƒD ] }t|tƒsjt|dd�rtt| j||j	dd�}t|tƒr}| ¡ }q]t|||
|||j	|ƒ | j |< }|S )NFrz  T)Úcheck_generic)Úinclude_generic)rì   rø   rù   r¦   r   ÚFieldr$   r*   rq   rU   r½   r8   r;   rG   r7   r-   r#   Úfound_in_pep593_annotatedrâ   )rQ   r©   rã   ré   r|  rç   ræ   Úallow_unmappedrU  r~  rå   rä   ÚelemÚcarP   rP   rR   rL  Û  sl   

ÿû	÷ÿü
€ù	z*_ClassScanMapperConfig._collect_annotationr  rß   c                 C  s,   t |tjƒrt d|› d|› d�¡ d S d S )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   ÚColumnElementr0   r«   )rQ   rq   r  rß   rP   rP   rR   rN  '  s
   ÿÿz0_ClassScanMapperConfig._warn_for_decl_attributesÚattributes_for_classr  rP  ú0Dict[str, Union[Column[Any], MappedColumn[Any]]]c                 C  sX  | j }| j}i }| j}|ƒ D ]›\}	}
}}|sJ|
d u rJt|||ƒrJ||	|
ƒr&q|  |	||d|
¡}|d ur6|jn|
}
|
d u r?tƒ }
|
||	< t||	|
ƒ qt|
t	tfƒr©||	|
ƒrWq|  |	||d|
¡}|d urg|jn|
}
|	|vr©d|v r~t
|
dd ƒpx|	|d jv s©|
jr—|
jD ]}|jd ur–|jjd u r–t d¡‚q„|
 ¡  ||
< }|||	< t||	|ƒ q|S )NTrK   r©   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:.)rq   rê   rð   r+   rL  rç   r)   rH  r¦   r3   r�   rß   Úforeign_keysÚ_table_columnr�   r   r´   Ú_copy)rQ   rž  r  rP  ré   rq   r˜   Úlocally_collected_attributesrð   r©   r¢   rT  ræ   rW  ÚfkÚcopy_rP   rP   rR   rB  4  sf   	ÿ
ÿ

ÿÿý

ÿÿýÿ

ÿ€
€z-_ClassScanMapperConfig._produce_column_copiesc                   sÄ  | j }| j}| j}| j}t|ddd�}| j}|p| j}t| jƒ}t	|ƒD �]:}	|	|v r,q$||	 ‰ t
ˆ ƒrEˆ jr?t d| j  ¡ t||	ƒ‰ ntˆ tƒr_ˆ j|ur_ˆ j|	kr_tˆ jƒ‰ t||	ˆ ƒ tˆ tƒr{tˆ ƒdkr{tˆ d ttfƒr{t d|	 ¡ q$|r„tˆ tjƒr„q$tˆ ttfƒs | |	¡ |  ||	ˆ ¡ |sŸt||	ˆ ƒ q$|	dv r­t d	|	› d
�¡‚tˆ tƒr½t |	| j! "ˆ ˆ ¡ƒ nžtˆ t#ƒ�r	| j$ "|	d¡\}
}}}}}}|d usÜ|
d u sÜ|�rzˆ  %| | j&|||	||
||¡	 W n t'�y } z
t (d|
› d�¡|‚d }~ww |�s	J ‚tˆ tƒ�r[ˆ j)�rG|�sGtˆ t*ƒ�r!g d¢}ng d¢}‡ fdd„|D ƒ}t (d|	› d|› dd +t,dd„ |D ƒƒ¡› d�¡‚tˆ t*t-fƒ�s[| |	¡ t||	ˆ ƒ q$ˆ ||	< q$d S )Nr{   Tr|   z�Use of @declared_attr.cascading only applies to Declarative 'mixin' and 'abstract' classes.  Currently, this flag is ignored on mapped class %sr   r   z‘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?)rZ   zAttribute 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)rh   r¦  ri   c                   s(   h | ]}t ˆ jd |› �ƒtjur|’qS )Údataclasses_)r�   Ú_attribute_optionsr2   r]  ©r  Úa©rÃ   rP   rR   Ú	<setcomp>-  s    ÿýþzF_ClassScanMapperConfig._extract_mappable_attributes.<locals>.<setcomp>r›  rœ  z# includes dataclasses argument(s): rb  c                 s  rc  rO   rd  rª  rP   rP   rR   r2  9  re  zF_ClassScanMapperConfig._extract_mappable_attributes.<locals>.<genexpr>zF but class does not specify SQLAlchemy native dataclass configuration.).rq   rë   r®   r+  r~   rù   rø   rz   r÷   r<  r¨   rª   r0   r«   r�   r¦   r   rˆ   r  r    rH  rD  rÝ   r3   r$   r   r–  r"   ÚpoprN  r   r´   Ú_undefer_column_namerð   r„   r#   rì   rº   r—   Ú	NameErrorrE  Ú_has_dataclass_argumentsr&   rn  rŽ  r%   )rQ   rq   rë   Ú	our_stuffr+  Úlate_mappedrù   Úexpect_annotations_wo_mappedÚlook_for_dataclass_thingsrv  rT  rä   rå   ræ   rç   rè   ré   ÚneÚargnamesÚargsrP   r¬  rR   r  Ž  sð   ÿÿ
ýÿÿ


ÿÿþÿÿ

ÿ
ÿ	ÿøû÷ÿÿû€ÿ
ÿþ

þ	þÿ


 �Ïz3_ClassScanMapperConfig._extract_mappable_attributesc              
   C  s2  | j }| j}| j}t t¡}t| ¡ ƒD ]c\}}t|t	ƒrV|j
}|r'|||< n||= |jD ]'\}}	t|tƒs>||j  |¡ | |¡ |	||< |d u rT||jkrT|||< q-qt|tƒrw|jd usbJ ‚||j  |¡ | |¡ ||jkrw||= q| ¡ D ]\}
}t|ƒdkr–t d| j|
d t|ƒ¡f ¡ q|d S )Nr   zzOn class %r, Column object %r named directly multiple times, only one will be used: %s. Consider using orm.synonym insteadrb  )r®   rî   rï   rj  rk  rŒ  r<  rl  r¦   r%   Úmapper_property_to_assignÚcolumns_to_assignr   r©   Úaddr  r3   rÝ   r0   r«   r­   rn  rŽ  )rQ   r²  rî   rï   Úname_to_prop_keyr  rß   Úmp_to_assignÚcolÚ
sort_orderr©   ÚkeysrP   rP   rR   r  S  sF   




€ð


€üÿ€þz0_ClassScanMapperConfig._extract_declared_columnsNc                   st  | j }td|ƒ}| j}| j}| j}| j}| j‰ t |¡}d|vr™|d u r™t	|dƒr5tt
t t |j¡ƒ}	nt}	|d ur˜d}
i }|rct|tƒrI|}nt|tƒrct|d tƒra|dd… |d }
}n|}
| d¡}|rn||d< | d	¡}|ryd
|d< t|‡ fdd„d�}|  d|	||  |¡g|¢|
¢R i |¤Ž¡}n|d u r |j}|rµ|D ]}|j |¡s´t d|j ¡‚q¤|| _d S )NúMappedClassProtocol[Any]rK   Ú__table_cls__rP   éÿÿÿÿr   Ú__autoload_with__Úautoload_withÚ__autoload__TÚautoloadc                   s   ˆ   | d¡S )Nr   r/  )rß   ©rï   rP   rR   Ú<lambda>º  s    z5_ClassScanMapperConfig._setup_table.<locals>.<lambda>©r  z8Can't add additional column %r when specifying __table__)rq   r   rò   rñ   rê   rî   rï   r   rÄ   rµ   r   r4   r0   Úunbound_method_to_callablerÂ  r¦   r>  rD  r„   rŽ  rÆ   Ú_metadata_for_clsrK   rß   Úcontains_columnr   rE  r  rÐ   )rQ   r�   rq   r@  rò   rñ   rê   rî   r–   Ú	table_clsr¸  Útable_kwrÅ  rÇ  Úsorted_columnsrß   rP   rÈ  rR   r  Ž  sz   



þ




þþýüûþ€ÿÿÿ
z#_ClassScanMapperConfig._setup_tabler–   úClassManager[Any]rB   c                 C  s"   t | jdd ƒ}|d ur|S |jjS )NrZ   )r�   rq   r—   rZ   )rQ   r–   ÚmetarP   rP   rR   rÌ  Ó  s   z(_ClassScanMapperConfig._metadata_for_clsc                 C  sÂ   | j }| dd ¡}|d u rAg }|jD ]}t|ƒ}|d u rqt|ƒr*||vr*| |¡ q|r@t|ƒdkr<t d||f ¡‚|d }nt	|t
ƒrI|j}|| _| j}d|vr]| jd u r_d| _d S d S d S )NrÑ   r   rÛ   r   rK   T)rq   r„   r…   r†   r   rÜ   rÝ   r   r´   r¦   r'   rˆ   rÑ   rê   rò   rõ   )rQ   rŸ   rq   rÑ   rÞ   r‰   rß   rê   rP   rP   rR   r  Ú  s6   

€ÿÿ€

ÿz/_ClassScanMapperConfig._setup_inheriting_mapperc           
   
   C  sX  | j }| j}| j}| j}|d u r!| jd u r!t|dƒs!t d| ¡‚| jr¦t| jƒ}|d us/J ‚|j }|j	}|d u r¨|r@t 
d¡‚|rUt|tƒsUt 
d| j› d| j› d�¡‚|D ]R}	|d us_J ‚|	j|jv r‚|j|	j |	u rnqWt 
d|	› d|j› d	|j|	j › d
�¡‚|	jrŠt 
d¡‚tr“t|tƒs“J ‚| |	¡ |d ur¥||ur¥| |	¡ qWd S d S d S )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 TablezColumn '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Ð   rq   rñ   rî   rÑ   r~   r   r´   ry   rí   rE  r¦   r4   r©   rß   rH   Úprimary_keyr   Úappend_columnÚ_refresh_for_new_column)
rQ   rŸ   r�   rq   rñ   rî   Úinherited_mapper_or_configÚinherited_tableÚinherited_persist_selectabler¾  rP   rP   rR   r  û  st   
ÿþÿ
ÿÿÿÿÿ
þÿÿ
ÿ€Ìz0_ClassScanMapperConfig._setup_inheriting_columnsc                   s¼  ˆj }ˆjrˆ ¡ }ni }|r| |¡ d|v r#t|ƒ}| |d ¡ dD ]}||v r8|| }ˆj ||¡||< q%d|v rM‡fdd„t |d ¡D ƒ|d< d|v rk|d }t|t	ƒr]|j
}|ˆjurkt d|d  ¡‚ˆjrsˆj|d< ˆjrÑ| dd	¡sÑtˆjd	ƒ‰ ˆ j}d
|vr¨‡ fdd„|jD ƒ ˆ jp—d¡ |d
< }| dd„ ˆjD ƒ¡ t| ¡ ƒD ]"\}}	t|	tjƒs¹q®|ˆ jv rÐˆ j| }
t|
tƒrÐ|	g|
j ||< q®| ¡ }||d< |ˆ_d S )Nr®   )Úversion_id_colÚpolymorphic_onrÔ  c                   s   g | ]	}ˆ j  ||¡‘qS rP   )rð   r„   )r  rw  rc   rP   rR   r-  Z  s    ÿÿzD_ClassScanMapperConfig._prepare_mapper_arguments.<locals>.<listcomp>rÑ   z:mapper inherits argument given for non-inheriting class %sÚconcreteFÚexclude_propertiesc                   s   h | ]
}|ˆ j vr|j’qS rP   )Ú_columntopropertyr  ©r  rß   )Úinherited_mapperrP   rR   r­  x  s
    
þzC_ClassScanMapperConfig._prepare_mapper_arguments.<locals>.<setcomp>rP   c                 S  s   g | ]}|j ‘qS rP   rÊ  rß  rP   rP   rR   r-  ~  s    )r®   rô   rC  r>  rð   r„   r0   Úto_listr¦   r'   rˆ   rÑ   r   r´   r,   rÐ   rß   ÚunionrÝ  Údifference_updaterî   r<  rl  r1   r�  Ú_propsr(   ÚcolumnsÚcopyró   )rQ   rŸ   r®   ró   rv  rw  Úinherits_argrØ  rÝ  r¾  ÚpÚresult_mapper_argsrP   )rà  rQ   rR   Ú_prepare_mapper_argumentsC  sj   

€

þ

ÿÿ

þ
üÿ



€
z0_ClassScanMapperConfig._prepare_mapper_argumentsrÇ   c                 C  sP   |   |¡ t| jdƒrtdt | jj¡ƒ}nt}|  d|| j| j	fi | j
¤Ž¡S )NÚ__mapper_cls__zType[Mapper[Any]]rJ   )rê  rµ   rq   r   r0   rË  rë  r'   rÆ   rÐ   ró   rÙ   rP   rP   rR   rÊ   ”  s   
ÿþþz_ClassScanMapperConfig.map)
r—   r=   r±   r“   r˜   r<   r�   rž   rŸ   r\   rf   )rq   r“   rM   r  )rq   rr   rM   r(  )rx  r“   rM   ry  )r÷   rg   rx  r“   r‚  ry  rM   rb   )rŠ  rg   rM   rb   )r©   rG   rã   r6   ré   rr   r|  r’  rç   r   rM   r“  )rq   rr   r  rG   rß   r   rM   rb   )
rž  r(  r  r  rP  rz   ré   rr   rM   rŸ  rO   )r�   rž   rM   rb   )r–   rÑ  rM   rB   rÍ   rÌ   )"rH   rU   rV   rÎ   Úis_deferredrX   rÂ   r  r'  r+  ÚreÚcompiler,  r=  r  r  rÏ   r�  ro  r„  rL  rN  rB  r  r  r  rÌ  r  r  rê  r0   rà   rÊ   rá   rP   rP   r×   rR   r¶   ¹  sh   
 	
M
L


D  
n4

L

Z 
F;
E

!
HQr¶   Úfield_metadatarû   r  c                 C  s2   t jj}| | }t|ƒrt||jƒs| |¡S |S rO   )r0   r£   r¤   Úcallabler¦   r?   )rï  r  Údecl_apir¢   rP   rP   rR   r7  ¦  s
   
r7  c                      s´   e Zd ZU ded< dZe ¡ Zded< d$d
d„Ze	d%dd„ƒZ
e
jd&dd„ƒZ
ed'dd„ƒZed(dd„ƒZed)dd„ƒZed*dd„ƒZe	d+d,dd „ƒZejfd-‡ fd"d#„Z‡  ZS ).ru   úweakref.ref[Type[Any]]Ú_clsTz?util.OrderedDict[weakref.ref[Type[Any]], _DeferredMapperConfig]Ú_configsrŸ   r\   rM   rb   c                 C  rN   rO   rP   rÉ   rP   rP   rR   rË   ¾  s   z$_DeferredMapperConfig._early_mappingrr   c                 C  s   |   ¡ S rO   )ró  rc   rP   rP   rR   rq   Â  s   z_DeferredMapperConfig.clsrˆ   c                 C  s    t  || j¡| _| | j| j< d S rO   )ÚweakrefÚrefÚ_remove_config_clsró  rô  )rQ   rˆ   rP   rP   rR   rq   Æ  s   rö  c                 C  s   | j  |d ¡ d S rO   )rô  r®  )rq   rö  rP   rP   rR   r÷  Ë  s   z(_DeferredMapperConfig._remove_config_clsrz   c                 C  s   t |tƒot |¡| jv S rO   )r¦   r½   rõ  rö  rô  ©rq   rˆ   rP   rP   rR   rv   Ï  s   z_DeferredMapperConfig.has_clsr   c                 C  s.   t |dƒr	| ¡  tj|dt |¡› 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ø  rP   rP   rR   Úraise_unmapped_for_clsÔ  s   
ýz,_DeferredMapperConfig.raise_unmapped_for_clsc                 C  s   | j t |¡ S rO   )rô  rõ  rö  rø  rP   rP   rR   rw   á  s   z$_DeferredMapperConfig.config_for_clsÚbase_clsÚsortúList[_DeferredMapperConfig]c                   sr   ‡fdd„dd„ | j  ¡ D ƒD ƒ}|s|S dd„ |D ƒ‰ g }ˆ D ]‰| ‡ ‡fdd„ˆjD ƒ¡ q tt ||¡ƒS )Nc                   s&   g | ]\}}|d urt |ˆ ƒr|‘qS rO   )rŽ   )r  Úmr±   )rþ  rP   rR   r-  é  s
    þz:_DeferredMapperConfig.classes_for_base.<locals>.<listcomp>c                 S  s   g | ]}||j f‘qS rP   rx   ©r  r  rP   rP   rR   r-  ë  s    c                 S  r5  rP   rx   r  rP   rP   rR   r  ò  s    z:_DeferredMapperConfig.classes_for_base.<locals>.<dictcomp>c                 3  s(   � | ]}|ˆ v rˆ | ˆ ˆ fV  qd S rO   rP   )r  rþ  )Úall_m_by_clsÚm_clsrP   rR   r2  ö  s   € þýz9_DeferredMapperConfig.classes_for_base.<locals>.<genexpr>)rô  ÚvaluesÚextendr…   r<  r5   rÿ  )rq   rþ  rÿ  Úclasses_for_baseÚtuplesrP   )r  rþ  r  rR   r  å  s   
þ
þz&_DeferredMapperConfig.classes_for_baserÇ   c                   s   | j  | jd ¡ tƒ  |¡S rO   )rô  r®  ró  rÒ   rÊ   rÉ   r×   rP   rR   rÊ   ý  s   z_DeferredMapperConfig.maprÍ   )rM   rr   )rˆ   rr   rM   rb   )rö  rò  rM   rb   )rˆ   rr   rM   rz   )rˆ   rr   rM   r   )rˆ   rr   rM   ru   )T)rþ  rr   rÿ  rz   rM   r   rÌ   )rH   rU   rV   rX   rì  r0   r¾   rô  rË   Úpropertyrq   ÚsetterrÏ   r÷  rv   rý  rw   r  rà   rÊ   rá   rP   rP   r×   rR   ru   µ  s,   
 
þ
ÿru   r  rÃ   úMapperProperty[Any]rb   c                 C  s8  d| j v r“td| ƒ}ddd„}t|tƒr+t||ƒ ||ƒj|dd	� |j ||¡ d
S t|tƒr_|j	}|j
D ]\}}t||ƒ ||ƒj|dd	� |sQ|j ||¡ q6|r]|j ||¡ d
S d
S t|tƒrm|j ||¡ d
S t|tƒr…|j|kr…t|jƒ}|j ||¡ d
S t | ||¡ |j ¡  d
S t | ||¡ 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.

    rJ   rÁ  ÚmcrM   r4   c                 S  s&   t | jtƒr	| jS t d| j›d�¡‚)Nz+Cannot add a new attribute to mapped class z) because it's not mapped against a table.)r¦   rK   r4   r   r´   rH   )r  rP   rP   rR   Ú_table_or_raise  s
   ÿz'_add_attribute.<locals>._table_or_raiseT)Úreplace_existingN)r  rÁ  rM   r4   )rƒ   r   r¦   r3   r¯  rÕ  rJ   Úadd_propertyr%   r¹  rº  r&   r   r  r    r½   Ú__setattr__Ú_expire_memoizations)rq   r  rÃ   Ú
mapped_clsr  Úmpr¾  r€  rP   rP   rR   Ú_add_attribute  s<   





ÿ

ÿ€ÿ

r  c                 C  sv   d| j v r3|| j v r3td| ƒjjs3| j | }t|ttttfƒr#t	dƒ‚t
 | |¡ td| ƒj ¡  d S t
 | |¡ d S )NrJ   rÁ  z<Can't un-map individual mapped attributes on a mapped class.)rƒ   r   rJ   Ú_dispose_calledr¦   r3   r%   r&   r   rÈ   r½   Ú__delattr__r  )rq   r  rÃ   rP   rP   rR   Ú_del_attribute6  s(   

ÿý
ÿÿÿr  rQ   Úkwargsc                 K  sB   t | ƒ}|D ]}t||ƒstd||jf ƒ‚t| ||| ƒ qdS )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†  rH   rH  )rQ   r  r±   rv  rP   rP   rR   Ú_declarative_constructorN  s   

ÿûr  rÂ   ÚcolumnúColumn[Any]c                 C  s(   |j d u r| |_ |jd u r| |_d S d S rO   )r  r©   )r  r  rP   rP   rR   r¯  d  s
   


ÿr¯  )rq   rr   rM   rs   )rq   rr   rM   rz   )rq   rr   rM   r€   )F)rq   rr   rŒ   rG   r}   rz   rM   r�   )rq   r“   rM   r”   )r—   r=   rq   rr   r˜   r<   rM   r™   )
r—   r=   rq   r“   r�   rž   rŸ   r\   rM   rI   )r¢   r   rM   rz   )r¢   r   r©   rG   rq   r“   rM   rz   )rï  rû   r  rG   rM   r   )rq   rr   r  rG   rÃ   r  rM   rb   )rq   rr   r  rG   rM   rb   )rQ   r   r  r   rM   rb   )r  rG   r  r  rM   rb   )rrW   Ú
__future__r   rj  r   rí  Útypingr   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   rõ  Ú r   r   r   rú  r   r   Ú_typingr   r   r   r   r‘   r   r   Údescriptor_propsr   r    Ú
interfacesr!   r"   r#   r$   r%   r&   Úmapperr'   r®   r(   r)   r0   r*   r+   r,   r-   r/   Úsqlr1   Úsql.baser2   Ú
sql.schemar3   r4   r5   Úutil.typingr6   r7   r8   r9   r:   r;   r<   r=   r>   rñ  r?   r@   Úsql.elementsrA   rB   Úsql.selectablerC   rD   rG   r\   Ú_TableArgsTyperF   rY   rg   ry   r   r†   r~   r‡   rœ   r¡   Úpreload_moduler¨   r¬   rš   r    râ   r¶   r7  ru   r  r  r  rH   r¯  rP   rP   rP   rR   Ú<module>   sÞ   


ÿ
'



Z>
           x
M
4
