a
    •˜ëjTI ã                   @  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�r6d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„ dIeIe  ƒZZG dJdK„ dKeZe  eIƒZ[G dLdM„ dMeJƒZ\dNdOdPœdQdR„Z]dNdSdPœdTdU„Z^dNdVdPœdWdX„Z_d•dNdZdSd[d\œd]d^„Z`d_d`dPœdadb„ZadcdNdddedfœdgdh„Zbdcd_didjdkdlœdmdn„Zce6 ddo¡dpdSdqœdrds„ƒZedpdZd_dSdtœdudv„ZfG dwdx„ dxƒZgG dydz„ dzegƒZhG d{d|„ d|eƒZiG d}d~„ d~egƒZje6 ddo¡ddZdpd€œd�d‚„ƒZkG dƒd„„ d„ejƒZldNdZd…d†d‡œdˆd‰„ZmdNdZd†dŠœd‹dŒ„Zndpdpd†d�œdŽd�„Zod�eo_pdZd‘d†d’œ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)Úget_args)Ú
is_fwd_ref)Ú
is_literal)ÚProtocol)Ú	TypedDict)Ú
_ClassDict)Ú_RegistryType)ÚMapped)Údeclared_attr)ÚClassManager)ÚNamedColumn)ÚMetaData)Ú
FromClauseÚ_T)Úbound.c                   @  s:   e Zd ZU dZded< ded< ded< d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__r   r   )ÚkwÚreturnc                 K  s   d S ©N© )ÚselfrL   rO   rO   úW/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/sqlalchemy/orm/decl_base.pyÚ__call__e   ó    zMappedClassProtocol.__call__N)rH   Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__rR   rO   rO   rO   rQ   rF   Z   s
   
rF   c                   @  sV   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d„Zd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_transformsÚNone©rM   c                 C  s   d S rN   rO   ©rP   rO   rO   rQ   Ú__declare_first__r   rS   z*_DeclMappedClassProtocol.__declare_first__c                 C  s   d S rN   rO   rc   rO   rO   rQ   Ú__declare_last__t   rS   z)_DeclMappedClassProtocol.__declare_last__N)rH   rT   rU   rV   rW   rd   re   rO   rO   rO   rQ   rX   h   s   
rX   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   rT   rU   rW   rO   rO   rO   rQ   rf   w   s   
rf   ú	Type[Any]z3Optional[Union[_DeferredMapperConfig, Mapper[Any]]]©ÚclsrM   c                 C  s0   t  | ¡rt  | ¡S t| ƒr(t| dd�S d S d S )NF)Ú	configure)Ú_DeferredMapperConfigÚhas_clsÚconfig_for_clsr   r,   ©rr   rO   rO   rQ   Ú_declared_mapping_info‚   s
    

rx   Úboolc                 C  s.   t  | ¡rt| ddd� S t| ƒr&dS 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©ÚstrictFN)rt   ru   Ú_get_immediate_cls_attrr   rw   rO   rO   rQ   Ú_is_supercls_for_inherits�   s    
ÿr~   úOptional[Type[Any]]c                 C  s\   | t u rd S | j dd¡rB| jD ]}t|ƒ}|d ur |  S q d S t| ƒ}|rT|jS | S d S )NÚ__abstract__F)ÚobjectÚ__dict__ÚgetÚ	__bases__Ú"_resolve_for_abstract_or_classicalÚ_dive_for_cls_managerÚclass_)rr   Úbase_ÚsupZ
clsmanagerrO   rO   rQ   r…   ¥   s    

r…   FrG   zOptional[Any])rr   Úattrnamer|   rM   c                 C  s†   |dksJ ‚t | tƒsdS || jv r.t| |ƒS | jdd… D ]D}t|ƒdu}||jv r<|| u sr|rn|| jv r<n |s<t||ƒ  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   T)Ú
issubclassr�   r‚   ÚgetattrÚ__mro__r†   r„   )rr   rŠ   r|   ÚbaseZ_is_classical_inheritsrO   rO   rQ   r}   »   s(    



ÿýý ý ür}   úType[_O]zOptional[ClassManager[_O]]c                 C  s&   | j D ]}t |¡}|r|  S qd S rN   )r�   r   Úopt_manager_of_class)rr   rŽ   ÚmanagerrO   rO   rQ   r†   â   s    
ÿ
r†   r=   r<   úOptional[_MapperConfig])Úregistryrr   Údict_rM   c                 C  s   t  | ||d i ¡S rN   )Ú_MapperConfigÚsetup_mapping)r“   rr   r”   rO   rO   rQ   Ú_as_declarativeð   s    r—   úOptional[FromClause]r[   rI   )r“   rr   ÚtableÚ	mapper_kwrM   c                 C  s   t | |||ƒ td|ƒjS )NzMappedClassProtocol[_O])Ú_ImperativeMapperConfigr   rJ   )r“   rr   r™   rš   rO   rO   rQ   Ú_mapperø   s    rœ   zsqlalchemy.orm.decl_apir   )ÚobjrM   c                 C  s   t jjj}t| |t jfƒS rN   )r0   Ú	preloadedÚorm_decl_apiÚ_declared_attr_commonÚ
isinstanceZclassproperty)r�   r    rO   rO   rQ   Ú_is_declarative_props  s    
r¢   )r�   Únamerr   rM   c                 C  s2   t | ƒr*t| ddƒr&t d||f ¡ dS 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£   rr   rO   rO   rQ   Ú_check_declared_props_nocascade	  s    þÿr¦   c                   @  s”   e Zd ZU dZded< ded< ded< ded	< ed
ddddddœdd„ƒZd
dddœdd„Zddddœdd„Zd#dddœdd„Z	dddœd d!„Z
d"S )$r•   )rr   Ú	classnameÚ
propertiesÚdeclared_attr_regÚ__weakref__rp   rr   rG   r§   z_util.OrderedDict[str, Union[Sequence[NamedColumn[Any]], NamedColumn[Any], MapperProperty[Any]]]r¨   zDict[declared_attr[Any], Any]r©   r=   r�   r<   r˜   r[   r’   )r“   Úcls_r”   r™   rš   rM   c                 C  s|   t  | ¡}|r*|j|u r*t d| ›d�¡‚|j dd¡r<d S t|ddd�pRt|dƒ}|rht	|||||ƒS t
|||||ƒS d S )	NúClass z, already has been instrumented declarativelyr€   Frz   Tr{   Z_sa_decl_prepare)r   r�   r‡   r   ÚInvalidRequestErrorr‚   rƒ   r}   Úhasattrrt   Ú_ClassScanMapperConfig)rr   r“   r«   r”   r™   rš   r‘   Z	defer_maprO   rO   rQ   r–   +  s&    	

ÿÿþ
ÿ
ÿz_MapperConfig.setup_mapping)r“   r«   rš   c                 C  sx   t  |td¡| _|j| _t  ¡ | _i | _| 	dd¡sNt
j| jd|| |jd� n&t | j¡}|rd|jstt d| j ¡‚d S )Nr«   Únon_primaryF)Úfinalizer“   Údeclarative_scanZinit_methodztClass %s has no primary mapper configured.  Configure a primary mapper first before setting up a non primary Mapper.)r0   Zassert_arg_typeÚtyperr   rH   r§   ÚOrderedDictr¨   r©   rƒ   r   Zregister_classÚconstructorr   r�   Ú	is_mappedr   r­   )rP   r“   r«   rš   r‘   rO   rO   rQ   Ú__init__J  s&    
û
þÿz_MapperConfig.__init__rD   )rŠ   ÚvaluerM   c                 C  s   t  | j¡}| ||¡ |S rN   )r   Úmanager_of_classrr   Zinstall_member)rP   rŠ   r¸   r‘   rO   rO   rQ   Úset_cls_attributef  s    z_MapperConfig.set_cls_attribute.úMapper[Any]©rš   rM   c                 C  s
   t ƒ ‚d S rN   )ÚNotImplementedError©rP   rš   rO   rO   rQ   Úmapk  s    z_MapperConfig.mapra   c                 C  s   |   |¡ d S rN   )r¿   r¾   rO   rO   rQ   Ú_early_mappingn  s    z_MapperConfig._early_mappingN).)rH   rT   rU   Ú	__slots__rW   Úclassmethodr–   r·   rº   r¿   rÀ   rO   rO   rO   rQ   r•     s   
r•   c                      sR   e Zd ZdZdddddœ‡ fdd„Zejfdd	d
œdd„Zdd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d¡sFt | j	| j
|j¡ |  |¡ |  |¡ W d   ƒ n1 sn0    Y  d S )NrK   r°   F)Úsuperr·   rº   rÃ   r   Ú_CONFIGURE_MUTEXrƒ   r   Ú	add_classr§   rr   Ú_class_registryÚ_setup_inheritancerÀ   )rP   r“   r«   r™   rš   ©Ú	__class__rO   rQ   r·   u  s    ÿ
z _ImperativeMapperConfig.__init__r»   r¼   c                 C  s"   t }|  d|| j| jfi |¤Ž¡S )NrJ   )r'   rº   rr   rÃ   ©rP   rš   Z
mapper_clsrO   rO   rQ   r¿   Š  s
    þz_ImperativeMapperConfig.mapra   c                 C  sœ   | j }| dd ¡}|d u r‚g }|jD ]0}t|ƒ}|d u r:q$t|ƒr$||vr$| |¡ q$|r’t|ƒdkrxt d||f ¡‚|d }nt	|t
ƒr’|j}|| _d S )NrÄ   r   ú&Class %s has multiple mapped bases: %rr   )rr   rƒ   r„   r…   r~   ÚappendÚlenr   r­   r¡   r'   r‡   rÄ   )rP   rš   rr   rÄ   Úinherits_searchrˆ   ÚcrO   rO   rQ   rÉ   ’  s*    
ÿÿ

z*_ImperativeMapperConfig._setup_inheritance)
rH   rT   rU   rÁ   r·   r0   Ú
EMPTY_DICTr¿   rÉ   Ú__classcell__rO   rO   rÊ   rQ   r›   r  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[_AnnotationScanType, str]Úextracted_mapped_annotationry   Úis_dataclassr   Ú
attr_valuerG   Úoriginating_modulerp   Úoriginating_classNro   rO   rO   rO   rQ   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$< dd%ddd&d'œ‡ fd(d)„Zd*d+œd,d-„Zd%d.d/œd0d1„Zh d2£Z	e
 d3¡Zd4d5d/œd6d7„Zd*d+œd8d9„Zd*d+œd:d;„Zed%d<d=œd>d?„ƒZed@d%d<d*dAœdBdC„ƒZed@d*dDœdEdF„ƒZdGdHd4dIdJdKdLœdMdN„Zd4dGdJd*dOœdPdQ„Zd5d.dd4dRdSœdTdU„Zd*d+œdVdW„Zd*d+œdXdY„Zdmdd*d[œd\d]„Zd^d_d`œdadb„Zd&d*dcœddde„Zd&d*dcœdfdg„Zd&d*dcœdhdi„Zejfd&djdcœdkdl„Z ‡  Z!S )nr¯   )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Ü   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Ä   ry   rè   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ƒp„t| jƒ| _t |¡ | _}t|dƒ}|rª|r¸|r¸t d¡‚t|oÀ|ƒ| _|  ¡  |  ¡  |  ¡  tj�\ t  !| j"| j|j#¡ |  $|¡ |  %¡  |  &¡  |  '|¡ |  (|¡ |  )|¡ W d   ƒ n1 �sH0    Y  d S )NFr`   Z__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   ZimmutabledictrÒ   rÜ   rÅ   r·   r“   rß   rÝ   rÞ   Z
OrderedSetrà   rá   râ   rè   rŒ   rr   rê   ry   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À   )	rP   r“   r«   r”   r™   rš   ZdcaZcldZsdkrÊ   rO   rQ   r·   ú  sR    ÿ
ÿ
ÿþÿ

ÿ	ÿ


z_ClassScanMapperConfig.__init__ra   rb   c                   sX   t ˆ jdƒr*t td¡ddœ‡ fdd„ƒ}t ˆ jdƒrTt td¡ddœ‡ fd	d
„ƒ}d S )Nre   Úafter_configuredra   rb   c                     s   t dˆ jƒ ¡  d S ©Nú_DeclMappedClassProtocol[Any])r   rr   re   rO   rc   rO   rQ   rù   J  s    ÿzG_ClassScanMapperConfig._setup_declared_events.<locals>.after_configuredrd   Úbefore_configuredc                     s   t dˆ jƒ ¡  d S rú   )r   rr   rd   rO   rc   rO   rQ   rü   R  s    ÿzH_ClassScanMapperConfig._setup_declared_events.<locals>.before_configured)r}   rr   r/   Zlistens_forr'   )rP   rù   rü   rO   rc   rQ   rñ   G  s    

z-_ClassScanMapperConfig._setup_declared_eventszCallable[[str, Any], bool]rq   c                   sˆ   | j rtˆdƒ‰nd‰ˆs2ddddœ‡fdd„}nR‡fd	d
„t ˆ¡D ƒ‰‡fdd
„t ˆ¡D ƒ‰tƒ ‰ ddd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ï   NrG   r   ry   )Úkeyr�   rM   c                   s   t ˆ | |ƒ|uS rN   )rŒ   )rý   r�   rw   rO   rQ   Úattribute_is_overriddeni  s    zR_ClassScanMapperConfig._cls_attr_override_checker.<locals>.attribute_is_overriddenc                   s$   i | ]}ˆ |j v r|j|j ˆ  “qS rO   ©rY   r£   ©Ú.0Úf©Úsa_dataclass_metadata_keyrO   rQ   Ú
<dictcomp>m  s   
þzE_ClassScanMapperConfig._cls_attr_override_checker.<locals>.<dictcomp>c                   s$   i | ]}ˆ |j v r|j|j ˆ  “qS rO   rÿ   r   r  rO   rQ   r  r  s   
þc                   s–   t |ƒr|j}ˆ | ˆ ¡}t |ƒr(|j}||u r4dS |ˆ ur@dS ˆ | ˆ ¡}tˆ| |ƒ}||u rddS |ˆ urzt|tƒrzdS ||u r†dS |ˆ ur’dS dS )NFT)r¢   Úfgetrƒ   rŒ   r¡   r   )rý   r�   ÚretZ	all_field)ÚabsentÚall_datacls_fieldsrr   Úlocal_datacls_fieldsrO   rQ   rþ   z  s,    
ÿ)ré   r}   r0   Údataclass_fieldsÚlocal_dataclass_fieldsr�   )rP   rr   rþ   rO   )r  r	  rr   r
  r  rQ   Ú_cls_attr_override_checkerX  s     ÿ
þ
þ(z1_ClassScanMapperConfig._cls_attr_override_checker>   r^   r\   rK   rZ   z^(?:_sa_|__)rp   z2Callable[[], Iterable[Tuple[str, Any, Any, bool]]]c                   s¬   t  |¡‰t|ƒ‰| j‰ | j‰‡ ‡fdd„t  tˆƒtˆƒ¡D ƒ‰| jrTt|dƒ‰nd‰ˆstddœ‡‡‡fdd„}n4d	d
„ t  	|¡D ƒ‰ˆ‰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 rO   )Úmatch)r  Ún)Ú_include_dundersÚ_match_exclude_dundersrO   rQ   Ú
<listcomp>¼  s   üz=_ClassScanMapperConfig._cls_attr_resolver.<locals>.<listcomp>rï   Nz$Iterable[Tuple[str, Any, Any, bool]]rb   c                     s   ‡ ‡fdd„ˆD ƒS )Nc                 3  s&   | ]}|ˆ  |¡ˆ   |¡d fV  qdS )FN©rƒ   )r  r£   )Úcls_annotationsÚcls_varsrO   rQ   Ú	<genexpr>Ð  s   ûüz`_ClassScanMapperConfig._cls_attr_resolver.<locals>.local_attributes_for_class.<locals>.<genexpr>rO   rO   )r  r  ÚnamesrO   rQ   Úlocal_attributes_for_classÍ  s    ùzM_ClassScanMapperConfig._cls_attr_resolver.<locals>.local_attributes_for_classc                 S  s   i | ]}|j |“qS rO   )r£   )r  ÚfieldrO   rO   rQ   r  Û  s   z=_ClassScanMapperConfig._cls_attr_resolver.<locals>.<dictcomp>c                  3  sd   ˆD ]Z} ˆ  | d ¡}|rDˆ|jv rD|jt|jˆƒˆ   |j¡dfV  q| ˆ  | ¡ˆ   | ¡dfV  qd S )NTF)rƒ   rY   r£   Ú_as_dc_declaredattr)r£   r  )r  r  r  Úfixed_sa_dataclass_metadata_keyr  r  rO   rQ   r  á  s    ÿþÿþ)
r0   Úget_annotationsÚvarsr  r  Zmerge_lists_w_orderingÚlistré   r}   r  )rP   rr   r  rO   )r  r  r  r  r  r  r  r  rQ   Ú_cls_attr_resolver­  s,    
ÿþÿÿz)_ClassScanMapperConfig._cls_attr_resolverc              	     s¶  | j }td|ƒ‰ | j}| j}| j}| j}d }d  }}d }	d }
d|v }|  | j ¡}g }|jD ]R}||uolt|ƒ}|  	|¡}|s–||ur–|  
||||¡}ni }| ||||f¡ qZ|D �]Ô\}}}}| |¡ |ƒ D �]´\}}}}||v �rü|dk�r(t|||ƒ}|�sú|�r|�rúddœ‡ fdd„}|}nÒ|dk�rXt|||ƒ}|
�sú|�rP|�rúˆ j}
n¢|dk�r’t|||ƒ}|�rú|	�súd	dœ‡ fd
d„}|}	nh|dk�rðt|||ƒ}|�sú|�rº|�rúˆ j}t|tttd ƒfƒ�sàt d¡‚||u�rúd}n
d�s†J ‚qÐ|�r,t|ƒrÐ|jsÐt d|j|||f ¡ qÐqÐ||u�r°t|ttfƒ�rLqÐ�q†t|tƒ�rft d¡‚�q†t|ƒ�rt|d u�s~J ‚|j�rÌ||v �r¢t d||f ¡ |  ||¡ ||<  ||< }t!|||ƒ nl|�rôt"||d ƒ}t|t#ƒ�sþ| $¡ }n
t"||ƒ}t|t#ƒ�r(t%|ƒ�r(t|j&tƒ�s(|j'}| ||< ||< t|ttfƒ�r\|j(d u �r\|j)|_(|  *|| +¡ |d|¡ n:t,|||ƒ�r |sÐ||v sÐ||d ƒsÐJ ‚qÐn|  -|||¡ qÐ|�r||v�sÎ|| |u�r|||ƒ�rÞJ ‚t|ƒ�rð| $¡ }|||< |  *|||d|¡ qÐ|  *|||d |¡}|d u�o0|j.d u}|d u�rB|j/n|}|d u �rv|�sv|�rv|d u�rj|ntƒ ||< qÐ||v rÐ|||< qÐq²|�rš|
�sšd }|| _0|
| _1|| _2|	| _3d S )Nrû   rK   r\   rí   rb   c                     s
   t ˆ jƒS rN   )Údictr\   rO   ©Úcls_as_DeclrO   rQ   Ú_mapper_args_fnB  s    z@_ClassScanMapperConfig._scan_attributes.<locals>._mapper_args_fnrZ   rC   c                     s   ˆ j S rN   )rK   rO   r!  rO   rQ   Ú	_table_fnX  s    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)4rr   r   rÜ   rÝ   râ   r  r  r�   r~   r  Ú_produce_column_copiesrÎ   Úupdater¦   rZ   r^   r¡   Útupler   r³   r   ÚArgumentErrorr¢   Z_quietr0   r¥   rH   r3   r)   r&   r­   r¤   Ú__get__ÚsetattrrŒ   r   r  r   Zoriginal_propertyZ
descriptorÚdocrV   Ú_collect_annotationZ_collect_return_annotationr+   Ú_warn_for_decl_attributesrÖ   rÙ   rã   rä   ræ   rç   )rP   rr   rÜ   rÝ   râ   r  ræ   rã   Zinherited_table_argsrç   rä   Úfixed_tablerþ   ÚbasesrŽ   Zclass_mappedr  Zlocally_collected_columnsr£   r�   Ú
annotationÚis_dataclass_fieldZ
check_declr#  r$  r  Úcollected_annotationr¶   Zgenerated_objrO   r!  rQ   rò   ñ  sn   


üüÿû
û

ÿÿÿ	
ÿ
ÿ
ÿÿÿ
üÿ
ÿ

ýÿ
þ

ÿþÿýÿÿþûÿþÿ
ÿ

ÿ
ÿ
þÿ
ýÿýz'_ClassScanMapperConfig._scan_attributesc              	     s’  ˆj }|sd S dˆjjv r.t dˆj› d�¡‚dˆjjv rNt dˆj› d�¡‚t t¡‰dddd	œ‡‡fd
d„‰ t 	ˆj¡}|d usˆJ ‚‡fdd„‡ ‡fdd„ˆj
 ¡ D ƒD ƒ}ˆrüˆ ¡ D ]>\}}tjdˆj› dd dd„ |D ƒ¡› d|› d�ddd� q¼i }i }|D ]R}t|ƒdk�r$|\}	}
n,t|ƒdk�rF|\}	}
}|||	< n
d�sPJ ‚|
||	< �q| ¡ D ]\}}tˆj||ƒ �qdˆ |ˆ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'rK   zk already defines a '__table__'. ORM Annotated Dataclasses do not support a pre-existing '__table__' elementrG   rp   ry   )rý   rÛ   rM   c                   s&   |ˆ j ur"d|jvr"ˆ|  | ¡ dS )Nr3  T)rr   r‚   rÎ   )rý   rÛ   )rP   Úwarn_for_non_dc_attrsrO   rQ   Ú_allow_dataclass_field;  s    ÿþzT_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>._allow_dataclass_fieldc                   s.   g | ]&\}}}t  |||ˆ j |tj¡¡‘qS rO   )r!   Z!_get_arguments_for_make_dataclassrÝ   rƒ   r2   ÚNO_ARG)r  rý   ÚannorÖ   rc   rO   rQ   r  I  s   úüzH_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>.<listcomp>c           	      3  sV   | ]N\}\}}}}}}}ˆ ||ƒr|ˆj vs<tˆj | tƒs||rF|n||fV  qd S rN   )rÝ   r¡   r   )	r  rý   Zraw_annorÖ   Zmapped_annoZis_dcrÙ   rÚ   rÛ   )r5  rP   rO   rQ   r  P  s"   


ÿé
ýzG_ClassScanMapperConfig._setup_dataclasses_transforms.<locals>.<genexpr>zWhen transforming z to a dataclass, attribute(s) ú, c                 s  s   | ]}t |ƒV  qd S rN   ©rh   )r  rý   rO   rO   rQ   r  x  rS   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.0Zdcmx©Úcoder.   é   F)rê   rr   r‚   r   r­   ÚcollectionsÚdefaultdictr  r   r¹   rÞ   Úitemsr0   Zwarn_deprecatedÚjoinrÏ   r*  Ú_apply_dataclasses_to_any_class)rP   rê   r‘   Z
field_listrÛ   Znon_dc_attrsr   ÚdefaultsÚitemr£   ÚtpÚspecÚkÚvrO   )r5  rP   r4  rQ   ró     sb    ÿÿ

òù'ý
þü
ô



ÿz4_ClassScanMapperConfig._setup_dataclasses_transformsz!Mapping[str, _AnnotationScanType])ÚklassrM   c           	      C  sl   t  |¡}i }| ¡ D ]P\}}t|||ƒr^t|||j|td ƒdddd�}|rf|\}}|||< q|||< q|S )NF©Úrequiredr1  Úexpect_mapped)r0   r  r?  r+   r*   rT   r³   )	rr   rH  r  Znew_annor£   r0  Ú	extractedÚinnerÚ_rO   rO   rQ   Ú(_update_annotations_for_non_mapped_class—  s&    
ø


z?_ClassScanMapperConfig._update_annotations_for_non_mapped_classrf   )rê   rH  Úuse_annotationsrM   c              
   C  sð   |   |¡ |d }|tju r"tj}|r>t |¡}td|ƒ|_nd }zŽz"||fi dd„ | 	¡ D ƒ¤Ž W nH t
tfy® } z,tjd|j›d|›d�dd	�|‚W Y d }~nd }~0 0 |j W |rì|d u rÊ|`qì||_n|rê|d u rä|`n||_0 d S )
Nrn   rí   c                 S  s(   i | ] \}}|t jur|d kr||“qS )rn   )r2   r6  )r  rF  rG  rO   rO   rQ   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.Zdcter:  )Ú_assert_dc_argumentsr2   r6  rð   Z	dataclassr0   r  r   rW   r?  Ú	TypeErrorÚ
ValueErrorr   r­   rH   rV   )rr   rê   rH  rP  rn   ZrestoredÚexrO   rO   rQ   rA  ±  sH    


ÿþþ
ÿþûúüz6_ClassScanMapperConfig._apply_dataclasses_to_any_class)Ú	argumentsrM   c                 C  sH   h d£}t |ƒ |¡}|rDd dd„ t|ƒD ƒ¡}t d|› d�¡‚d S )N>   rg   rj   rh   ri   rn   rk   rm   rl   r8  c                 s  s   | ]}|›V  qd S rN   rO   )r  ÚargrO   rO   rQ   r    rS   z>_ClassScanMapperConfig._assert_dc_arguments.<locals>.<genexpr>zDataclass argument(s) z are not accepted)ÚsetÚ
differencer@  Úsortedr   r(  )rr   rU  ÚallowedZdisallowed_argsÚmsgrO   rO   rQ   rQ  ô  s    

ÿz+_ClassScanMapperConfig._assert_dc_argumentsrG   r6   zOptional[bool]r   zOptional[_CollectedAnnotation])r£   rÕ   rÛ   rK  rÙ   rM   c              
   C  s  || j v r| j | S |d u r d S | j}| j}|d u r^t|tjƒ}| o\| o\|d u p\t|tƒ}d}t|| j|j	|t
|ƒd||o‚| d�}	|	d u r”d S |	\}
}|d u rît|
ƒsît|
ƒD ]8}t|ddd�rÚt| j||j	dd�}t|tƒr´| ¡ }q´t|||
|||j	|ƒ | j |< }|S )NFrI  T)Zcheck_genericZcheck_for_plain_string)Zinclude_generic)rÞ   rë   rì   r¡   rð   ÚFieldr$   r*   rr   rT   r³   r9   r7   r8   r-   r#   Zfound_in_pep593_annotatedrÔ   )rP   r£   rÕ   rÛ   rK  rÙ   rØ   Zallow_unmappedr1  rL  r×   rÖ   ÚelemÚcarO   rO   rQ   r,    sf    

ÿû	ø
ÿü

ù	z*_ClassScanMapperConfig._collect_annotation)rr   rý   rÑ   rM   c                 C  s(   t |tjƒr$t d|› d|› d�¡ 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¥   )rP   rr   rý   rÑ   rO   rO   rQ   r-  O  s    ÿz0_ClassScanMapperConfig._warn_for_decl_attributesz0Dict[str, Union[Column[Any], MappedColumn[Any]]])Úattributes_for_classrþ   r.  rÛ   rM   c                 C  sd  | j }| j}i }| j}|ƒ D �]@\}	}
}}|s–|
d u r–t|||ƒr–||	|
ƒrNq|  |	||d|
¡}|d urn|jn|
}
|
d u r€tƒ }
|
||	< t||	|
ƒ qt|
t	tfƒr||	|
ƒr°q|  |	||d|
¡}|d urÐ|jn|
}
|	|vrd|v �r t
|
dd ƒpô|	|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:.)rr   rÜ   râ   r+   r,  rÙ   r)   r*  r¡   r3   rŒ   rÑ   Zforeign_keysZ_table_columnr™   r   r­   Z_copy)rP   rb  rþ   r.  rÛ   rr   r”   Zlocally_collected_attributesrâ   r£   r�   r0  rØ   r2  ZfkZcopy_rO   rO   rQ   r%  \  sl    	ÿþ
ý

ÿÿý

ÿÿýÿÿþ
ÿ
þÿ
z-_ClassScanMapperConfig._produce_column_copiesc                   sò  | j }| j}| j}| j}t|ddd�}| j}|p4| j}t| jƒ}t	|ƒD �]¢}	|	|v rXqH||	 ‰ t
ˆ ƒrŠˆ jr~t d| j  ¡ t||	ƒ‰ n4tˆ 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|	 ¡ qH�nê|�rtˆ tjƒ�rqH�nÐtˆ ttfƒ�sR| |	¡ |  ||	ˆ ¡ |sHt||	ˆ ƒ qH�n’|	dv �rrt d	|	› d
�¡‚�nrtˆ tƒ�r–t |	| j! "ˆ ˆ ¡ƒ �nNtˆ t#ƒ�r@| j$ "|	d¡\}
}}}}}}|d u�sØ|
d u �sØ|�r6z ˆ  %| | j&|||	||
||¡	 W n: t'�y2 } z t( )d|
› d�¡|‚W Y d }~n
d }~0 0 n
|�s@J ‚tˆ tƒ�räˆ j*�r¼|�s¼tˆ t+ƒ�rpg d¢}ng d¢}‡ fdd„|D ƒ}t ,d|	› d|› dd -t.dd„ |D ƒƒ¡› d�¡‚tˆ t+t/fƒ�sä| |	¡ t||	ˆ ƒ qHˆ ||	< qHd S )Nrz   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?)rY   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.)rg   Údefault_factoryrh   ÚdefaultÚdataclass_metadata)rg   rc  rh   re  c                   s(   h | ] }t ˆ jd |› �ƒtjur|’qS )Zdataclasses_)rŒ   Z_attribute_optionsr2   r6  ©r  Úa©r¸   rO   rQ   Ú	<setcomp>[  s   ÿýþzF_ClassScanMapperConfig._extract_mappable_attributes.<locals>.<setcomp>r_  r`  z# includes dataclasses argument(s): r8  c                 s  s   | ]}t |ƒV  qd S rN   r9  rf  rO   rO   rQ   r  g  rS   zF_ClassScanMapperConfig._extract_mappable_attributes.<locals>.<genexpr>zF but class does not specify SQLAlchemy native dataclass configuration.)0rr   rÝ   r¨   r  r}   rì   rë   ry   rê   r  r¢   r¤   r0   r¥   rŒ   r¡   r   r‡   rý   r    r*  r'  rÏ   r3   r$   rð   r\  r"   Úpopr-  r   r­   Ú_undefer_column_namerâ   rƒ   r#   rÞ   r²   r“   Ú	NameErrorÚorm_excZMappedAnnotationErrorZ_has_dataclass_argumentsr&   r(  r@  rY  r%   )rP   rr   rÝ   Ú	our_stuffr  Zlate_mappedrì   Zexpect_annotations_wo_mappedZlook_for_dataclass_thingsrF  r0  rÖ   r×   rØ   rÙ   rÚ   rÛ   ÚneÚargnamesÚargsrO   rh  rQ   rõ   ¶  sò    ÿÿ
ýÿÿþý
ÿ
þýþÿÿ


ÿÿ	ÿøÿþù	÷ÿÿû
ÿþ

þ	þÿ

z3_ClassScanMapperConfig._extract_mappable_attributesc              
   C  s2  | j }| j}| j}t t¡}t| ¡ ƒD ]Æ\}}t|t	ƒr¬|j
}|rN|||< n||= |jD ]N\}}	t|tƒs|||j  |¡ | |¡ |	||< |d u rZ||jkrZ|||< qZq(t|tƒr(|jd usÄJ ‚||j  |¡ | |¡ ||jkr(||= q(| ¡ D ]4\}
}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 insteadr8  )r¨   rà   rá   r=  r>  rW  r  r?  r¡   r%   Úmapper_property_to_assignÚcolumns_to_assignr   r£   Úaddrý   r3   rÏ   r0   r¥   r§   r@  rY  )rP   rn  rà   rá   Zname_to_prop_keyrý   rÑ   Zmp_to_assignÚcolZ
sort_orderr£   ÚkeysrO   rO   rQ   rö   �  s<    







üÿz0_ClassScanMapperConfig._extract_declared_columnsN)r™   rM   c                   sª  | j }td|ƒ}| j}| j}| j}| j}| j‰ t |¡}| j	d u �rFd|v�rF|d u �rFt
|dƒrzttt t |j¡ƒ}	nt}	|d u�r d}
i }|rØt|tƒr¤|}n4t|tƒrØt|d tƒrÔ|dd… |d  }
}n|}
| d¡}|rî||d< | d	¡}|�rd
|d< t|‡ fdd„d�}|  d|	||  |¡g|¢|
¢R i |¤Ž¡}nZ|d u �rp| j	�rj|  d|  	¡ ¡}n|j}|�r |D ]$}|j |¡�szt d|j ¡‚�qz|| _d S )NúMappedClassProtocol[Any]rK   Ú__table_cls__rO   éÿÿÿÿr   Z__autoload_with__Úautoload_withZ__autoload__TÚautoloadc                   s   ˆ   | d¡S )Nr   r  )rÑ   ©rá   rO   rQ   Ú<lambda>ì  rS   z5_ClassScanMapperConfig._setup_table.<locals>.<lambda>©rý   z8Can't add additional column %r when specifying __table__)rr   r   rä   rã   rÜ   rà   rá   r   r¹   rç   r®   r   r4   r0   Úunbound_method_to_callablerx  r¡   r   r'  rƒ   rY  rº   Ú_metadata_for_clsrK   rÑ   Zcontains_columnr   r(  rý   rÃ   )rP   r™   rr   r"  rä   rã   rÜ   rà   r‘   Z	table_clsrq  Ztable_kwrz  r{  Zsorted_columnsrÑ   rO   r|  rQ   r÷   ¼  sˆ    

ÿþý

þ





þþýüûþ
ÿÿÿz#_ClassScanMapperConfig._setup_tablezClassManager[Any]rB   )r‘   rM   c                 C  s&   t | jdd ƒ}|d ur|S |jjS d S )NrY   )rŒ   rr   r“   rY   )rP   r‘   ÚmetarO   rO   rQ   r€  
  s    z(_ClassScanMapperConfig._metadata_for_clsr¼   c                 C  sº   | j }| dd ¡}|d u r‚g }|jD ]0}t|ƒ}|d u r:q$t|ƒr$||vr$| |¡ q$|r’t|ƒdkrxt d||f ¡‚|d }nt	|t
ƒr’|j}|| _| j}d|vr¶| jd u r¶d| _d S )NrÄ   r   rÍ   r   rK   T)rr   rƒ   r„   r…   r~   rÎ   rÏ   r   r­   r¡   r'   r‡   rÄ   rÜ   rä   rè   )rP   rš   rr   rÄ   rÐ   rˆ   rÑ   rÜ   rO   rO   rQ   rô     s0    
ÿÿ

z/_ClassScanMapperConfig._setup_inheriting_mapperc           
   
   C  s`  | j }| j}| j}| j}|d u rF| jd u rFt|dƒsFt d| ¡‚�n| j�r\t| jƒ}|d usdJ ‚|j }|j	}|d u �r\|rˆt 
d¡‚|r²t|tƒs²t 
d| j› d| j› d�¡‚|D ]¤}	|d usÆJ ‚|	j|jv �r|j|	j |	u ræq¶t 
d|	› d|j› d	|j|	j › d
�¡‚|	j�r t 
d¡‚t�r6t|tƒ�s6J ‚| |	¡ |d ur¶||ur¶| |	¡ q¶d S )NZ__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Ã   rr   rã   rà   rÄ   r}   r   r­   rx   rß   r(  r¡   r4   r£   rÑ   rH   Úprimary_keyr   Úappend_columnZ_refresh_for_new_column)
rP   rš   r™   rr   rã   rà   Zinherited_mapper_or_configÚinherited_tableZinherited_persist_selectableru  rO   rO   rQ   rø   2  st    ÿþýþÿ
ÿ
ÿÿÿÿ
þÿÿ
ÿþÿz0_ClassScanMapperConfig._setup_inheriting_columnsc                   sÎ  ˆj }ˆjrˆ ¡ }ni }|r(| |¡ d|v rFt|ƒ}| |d ¡ dD ]&}||v rJ|| }ˆj ||¡||< qJd|v rš‡fdd„t |d ¡D ƒ|d< d|v rÖ|d }t|t	ƒrº|j
}|ˆjurÖt d|d  ¡‚ˆjræˆj|d< ˆj�r´| dd	¡�s´tˆjd	ƒ‰ ˆ j}d
|v�rX‡ fdd„|jD ƒ ˆ j�p6d¡ |d
< }| dd„ ˆjD ƒ¡ t| ¡ ƒD ]N\}}	t|	tjƒ�s~�qd|ˆ jv �rdˆ j| }
t|
tƒ�rd|	g|
j ||< �qd| ¡ }||d< |ˆ_d S )Nr¨   )Zversion_id_colZpolymorphic_onr‚  c                   s   g | ]}ˆ j  ||¡‘qS rO   )râ   rƒ   )r  rG  rc   rO   rQ   r  ‘  s   ÿzD_ClassScanMapperConfig._prepare_mapper_arguments.<locals>.<listcomp>rÄ   z:mapper inherits argument given for non-inheriting class %sZconcreteFÚexclude_propertiesc                   s   h | ]}|ˆ j vr|j’qS rO   )Z_columntopropertyrý   ©r  rÑ   )Úinherited_mapperrO   rQ   ri  ¯  s   
þzC_ClassScanMapperConfig._prepare_mapper_arguments.<locals>.<setcomp>rO   c                 S  s   g | ]
}|j ‘qS rO   r~  r†  rO   rO   rQ   r  µ  rS   )r¨   ræ   r&  r   râ   rƒ   r0   Zto_listr¡   r'   r‡   rÄ   r   r­   r,   rÃ   rÑ   Úunionr…  Údifference_updaterà   r  r?  r1   ra  Z_propsr(   ÚcolumnsÚcopyrå   )rP   rš   r¨   rå   rF  rG  Zinherits_argr„  r…  ru  ÚpZresult_mapper_argsrO   )r‡  rP   rQ   Ú_prepare_mapper_argumentsz  sf    


þ


ÿÿ


þ
üÿ

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®   rr   r   r0   r  rŽ  r'   rº   rÃ   rå   rÌ   rO   rO   rQ   r¿   Ë  s    
ÿþþz_ClassScanMapperConfig.map)N)"rH   rT   rU   rÁ   Úis_deferredrW   r·   rñ   r  r  ÚreÚcompiler  r  rò   ró   rÂ   rO  rA  rQ  r,  r-  r%  rõ   rö   r÷   r€  rô   rø   r�  r0   rÒ   r¿   rÓ   rO   rO   rÊ   rQ   r¯   º  sb   

ML
D  0xBHZ L;N!HQr¯   rî   )Úfield_metadatar  rM   c                 C  s6   t jj}| | }t|ƒr.t||jƒs.| |¡S |S d S rN   )r0   rž   rŸ   Úcallabler¡   r?   )r’  r  Údecl_apir�   rO   rO   rQ   r  Ý  s
    
r  c                      sè   e Zd ZU ded< dZe ¡ Zded< dddœd	d
„Ze	ddœdd„ƒZ
e
jdddœdd„ƒZ
edddœdd„ƒZedddœdd„ƒZedddœdd„ƒZedd dœdd„ƒZed#ddddœdd„ƒZejfdd dœ‡ fd!d"„Z‡  ZS )$rt   zweakref.ref[Type[Any]]Ú_clsTz?util.OrderedDict[weakref.ref[Type[Any]], _DeferredMapperConfig]Ú_configsr[   ra   r¼   c                 C  s   d S rN   rO   r¾   rO   rO   rQ   rÀ   õ  s    z$_DeferredMapperConfig._early_mappingrp   rb   c                 C  s   |   ¡ S rN   )r•  rc   rO   rO   rQ   rr   ø  s    z_DeferredMapperConfig.cls)r‡   rM   c                 C  s    t  || j¡| _| | j| j< d S rN   )ÚweakrefÚrefÚ_remove_config_clsr•  r–  )rP   r‡   rO   rO   rQ   rr   ü  s    )r˜  rM   c                 C  s   | j  |d ¡ d S rN   )r–  rj  )rr   r˜  rO   rO   rQ   r™    s    z(_DeferredMapperConfig._remove_config_clsry   c                 C  s   t |tƒot |¡| jv S rN   )r¡   r³   r—  r˜  r–  ©rr   r‡   rO   rO   rQ   ru     s    z_DeferredMapperConfig.has_clsr   c                 C  s2   t |dƒr| ¡  tj|dt |¡› d�d�‚d S )NÚ_sa_raise_deferred_configr¬   zG has a deferred mapping on it.  It is not yet usable as a mapped class.)r[  )r®   r›  rm  ZUnmappedClassErrorZ_safe_cls_namerš  rO   rO   rQ   Úraise_unmapped_for_cls
  s    
ýz,_DeferredMapperConfig.raise_unmapped_for_clsc                 C  s   | j t |¡ S rN   )r–  r—  r˜  rš  rO   rO   rQ   rv     s    z$_DeferredMapperConfig.config_for_clszList[_DeferredMapperConfig])Úbase_clsÚsortrM   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 rN   )r‹   )r  Úmr«   )r�  rO   rQ   r    s   þz:_DeferredMapperConfig.classes_for_base.<locals>.<listcomp>c                 S  s   g | ]}||j f‘qS rO   rw   ©r  rŸ  rO   rO   rQ   r  !  rS   c                 S  s   i | ]}|j |“qS rO   rw   r   rO   rO   rQ   r  (  rS   z:_DeferredMapperConfig.classes_for_base.<locals>.<dictcomp>c                 3  s&   | ]}|ˆ v rˆ | ˆ ˆ fV  qd S rN   rO   )r  r�  )Úall_m_by_clsÚm_clsrO   rQ   r  ,  s   þz9_DeferredMapperConfig.classes_for_base.<locals>.<genexpr>)r–  ÚvaluesÚextendr„   r  r5   rž  )rr   r�  rž  Úclasses_for_baseZtuplesrO   )r¡  r�  r¢  rQ   r¥    s    
þþ
z&_DeferredMapperConfig.classes_for_baser»   c                   s   | j  | jd ¡ tƒ  |¡S rN   )r–  rj  r•  rÅ   r¿   r¾   rÊ   rO   rQ   r¿   3  s    z_DeferredMapperConfig.map)T)rH   rT   rU   rW   r�  r0   r´   r–  rÀ   Úpropertyrr   ÚsetterrÂ   r™  ru   rœ  rv   r¥  rÒ   r¿   rÓ   rO   rO   rÊ   rQ   rt   ì  s*   
þ
 ÿrt   zMapperProperty[Any]ra   )rr   rý   r¸   rM   c                 C  s6  d| j v �r$td| ƒ}dddœdd„}t|tƒr\t||ƒ ||ƒj|dd� |j ||¡ nÆt|tƒr¾|j	}|j
D ]6\}}t||ƒ ||ƒj|dd� |sr|j ||¡ qr|r¼|j ||¡ ndt|tƒrØ|j ||¡ nJt|tƒ�r
|j|k�r
t|jƒ}|j ||¡ nt | ||¡ |j ¡  n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   rw  r4   )ÚmcrM   c                 S  s*   t | jtƒr| jS t d| j›d�¡‚d S )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¨  rO   rO   rQ   Ú_table_or_raiseE  s
    ÿz'_add_attribute.<locals>._table_or_raiseT)Zreplace_existingN)r‚   r   r¡   r3   rk  rƒ  rJ   Zadd_propertyr%   rr  rs  r&   r   rý   r    r³   Ú__setattr__Ú_expire_memoizations)rr   rý   r¸   Z
mapped_clsr©  Úmpru  rN  rO   rO   rQ   Ú_add_attribute8  s8    



ÿ

ÿ

r­  )rr   rý   rM   c                 C  sv   d| j v rf|| j v rftd| ƒjjsf| j | }t|ttttfƒrHt	dƒ‚qrt
 | |¡ td| ƒj ¡  nt
 | |¡ d S )NrJ   rw  z<Can't un-map individual mapped attributes on a mapped class.)r‚   r   rJ   Z_dispose_calledr¡   r3   r%   r&   r   r½   r³   Ú__delattr__r«  )rr   rý   r¸   rO   rO   rQ   Ú_del_attributel  s(    ÿþÿý
ÿÿÿr¯  )rP   ÚkwargsrM   c                 K  sB   t | ƒ}|D ]0}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®   rR  rH   r*  )rP   r°  r«   rF  rO   rO   rQ   Ú_declarative_constructor„  s    

ÿr±  r·   zColumn[Any])rý   ÚcolumnrM   c                 C  s$   |j d u r| |_ |jd u r | |_d S rN   )rý   r£   )rý   r²  rO   rO   rQ   rk  š  s    

rk  )F)rrV   Ú
__future__r   r=  rð   r�  Útypingr   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r—  Ú r   r   r   rm  r   r   Ú_typingr   r   r   r   rŽ   r   r   Zdescriptor_propsr   r    Z
interfacesr!   r"   r#   r$   r%   r&   Zmapperr'   r¨   r(   r)   r0   r*   r+   r,   r-   r/   Zsqlr1   Zsql.baser2   Z
sql.schemar3   r4   r5   Zutil.typingr6   r7   r8   r9   r:   r;   r<   r=   r>   r”  r?   r@   Zsql.elementsrA   rB   Zsql.selectablerC   rD   rG   r[   Z_TableArgsTyperF   rX   rf   rx   r~   r…   r}   r†   r—   rœ   Zpreload_moduler¢   r¦   r•   r›   rÔ   r¯   r  rt   r­  r¯  r±  rH   rk  rO   rO   rO   rQ   Ú<module>   sÞ    ÿ'
Z>
            /L4