o gXE@sdZddlmZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd 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/d2lm?Z?d/d4l@mAZAd/d5l@mBZBd/d6l6mCZCd/d7lDmEZEd/d8lDmFZFd/d9lDmGZGd/d:lDmHZHd/d;lDmIZId/dlmLZLdd?l$mMZMdd@lNmOZOddAlmPZPd/dBlQmRZRd/dCl@mSZSd/dDlTmUZUedEedFZVe eWefZXeeedGfe eWeffZYGdHdIdIeIe ZZGdJdKdKeZe eIZ[GdLdMdMeJZ\ddRdSZ]ddUdVZ^ddXdYZ_ Zddd_d`Z`ddcddZaddjdkZbddqdrZce6ddsddvdwZeddydzZfGd{d|d|ZgGd}d~d~egZhGdddeZiGdddegZje6ddsdddZkGdddejZldddZmdddZndddZodeo_pdddZqdS)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)MappedClassProtocolzA 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__kwrreturnrcKdSN)selfrLrPrPT/var/www/html/flaskapp/venv/lib/python3.10/site-packages/sqlalchemy/orm/decl_base.py__call__ezMappedClassProtocol.__call__N)rLrrMr)rH __module__ __qualname____doc____annotations__rSrPrPrPrRrFZs rFc@sNeZdZUdZded<ded<ded<ded <d ed <dddZdddZdS)_DeclMappedClassProtocolz:Internal more detailed version of ``MappedClassProtocol``.rBmetadatarG __tablename__ _MapperKwArgs__mapper_args__Optional[_TableArgsType]__table_args__Optional[_DataclassArguments]_sa_apply_dc_transformsrMNonecCrNrOrPrQrPrPrR__declare_first__qrTz*_DeclMappedClassProtocol.__declare_first__cCrNrOrPrcrPrPrR__declare_last__srTz)_DeclMappedClassProtocol.__declare_last__NrMrb)rHrUrVrWrXrdrerPrPrPrRrYhs  rYc@sNeZdZUded<ded<ded<ded<ded<ded<ded<d ed <d S) _DataclassArgumentszUnion[_NoArg, bool]initrepreqorder unsafe_hash match_argskw_onlyz'Union[_NoArg, Callable[..., Type[Any]]]dataclass_callableNrHrUrVrXrPrPrPrRrgvs  rgcls Type[Any]rM3Optional[Union[_DeferredMapperConfig, Mapper[Any]]]cCs,t|r t|St|rt|ddSdS)NF) configure)_DeferredMapperConfighas_clsconfig_for_clsrr,rqrPrPrR_declared_mapping_infos   ryboolcCs*t|r t|ddd St|rdSdS)areturn 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_nocascadeTstrictF)rurv_get_immediate_cls_attrrrxrPrPrR_is_supercls_for_inheritss rOptional[Type[Any]]cCsX|turdS|jddr!|jD]}t|}|dur|SqdSt|}|r*|jS|S)N __abstract__F)object__dict__get __bases__"_resolve_for_abstract_or_classical_dive_for_cls_managerclass_)rqbase_sup clsmanagerrPrPrRrs rFattrnamerGr} Optional[Any]cCs|dksJt|ts dS||jvrt||S|jddD]#}t|du}||jvrA||us:|r7||jvrAn |sAt||SqdS)areturn 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. rNr) issubclassrrgetattr__mro__rr)rqrr}base_is_classical_inheritsrPrPrRr~s"      r~Type[_O]Optional[ClassManager[_O]]cCs&|jD] }t|}|r|SqdSrO)rropt_manager_of_class)rqrmanagerrPrPrRrs rregistryr=dict_r<Optional[_MapperConfig]cCst|||diSrO) _MapperConfig setup_mapping)rrqrrPrPrR_as_declarativesrtableOptional[FromClause] mapper_kwr\rIcCst||||td|jS)NzMappedClassProtocol[_O])_ImperativeMapperConfigrrJ)rrqrrrPrPrR_mappers rzsqlalchemy.orm.decl_apiobjrcCstjjj}t||tjfSrO)r0 preloaded orm_decl_api_declared_attr_common isinstance classproperty)rrrPrPrR_is_declarative_propss rnamecCs.t|rt|ddrtd||fdSdS)N _cascadingFz~@declared_attr.cascading is not supported on the %s attribute on class %s. This attribute invokes for subclasses in any case.T)rrr0warn)rrrqrPrPrR_check_declared_props_nocascades rc@sjeZdZUdZded<ded<ded<ded <ed'ddZd(ddZd)ddZd*d+d!d"Z d,d$d%Z d&S)-r)rq classname propertiesdeclared_attr_reg __weakref__rrrqrGrz_util.OrderedDict[str, Union[Sequence[NamedColumn[Any]], NamedColumn[Any], MapperProperty[Any]]]rzDict[declared_attr[Any], Any]rrr=cls_rrr<rrrr\rMrcCsxt|}|r|j|urtd|d|jddrdSt|dddp)t|d}|r4t |||||St |||||S) NClass z, already has been instrumented declarativelyrFr{Tr|_sa_decl_prepare) rrrrInvalidRequestErrorrrr~hasattrru_ClassScanMapperConfig)rqrrrrrr defer_maprPrPrRr*s&    z_MapperConfig.setup_mappingcCszt|td|_|j|_t|_i|_| dds(t j |jd|||j ddSt |j}|r3|js;td|jdS)Nr non_primaryF)finalizerdeclarative_scan init_methodztClass %s has no primary mapper configured. Configure a primary mapper first before setting up a non primary Mapper.)r0assert_arg_typetyperqrHr OrderedDictrrrrregister_class constructorrr is_mappedrr)rQrrrrrPrPrR__init__Is(    z_MapperConfig.__init__rvaluerDcCst|j}||||SrO)rmanager_of_classrqinstall_member)rQrrrrPrPrRset_cls_attributees  z_MapperConfig.set_cls_attribute. Mapper[Any]cCstrO)NotImplementedErrorrQrrPrPrRmapjz_MapperConfig.maprbcCs||dSrO)rrrPrPrR_early_mappingmsz_MapperConfig._early_mappingN) rr=rrrr<rrrr\rMr)rr=rrrrr\)rrGrrDrMrD).rr\rMrrr\rMrb) rHrUrV __slots__rX classmethodrrrrrrPrPrPrRrs     rcs<eZdZdZdfd d ZejfdddZdddZZ S)r) local_tableinheritsrr=rrrrrr\cs~t||||d||_tj#|dds#t|j |j |j | || |WddS1s8wYdS)NrKrF)superrrrr_CONFIGURE_MUTEXrr add_classrrq_class_registry_setup_inheritancer)rQrrrr __class__rPrRrts    "z _ImperativeMapperConfig.__init__rMrcCs"t}|d||j|jfi|S)NrJ)r'rrqrrQr mapper_clsrPrPrRrs z_ImperativeMapperConfig.maprbcCs|j}|dd}|durAg}|jD]}t|}|durqt|r*||vr*||q|r@t|dkrZedydAdBZedzdEdFZed{dHdIZd|dTdUZd}dXdYZd~d^d_Zdvd`daZdvdbdcZdddedfZddjdkZddldmZddndoZddpdqZejfddsdtZ Z!S)r)r clsdict_viewcollected_attributescollected_annotationsrpersist_selectabledeclared_columnscolumn_ordering column_copies table_args tablename mapper_argsmapper_args_fntable_fnrsingleallow_dataclass_fieldsdataclass_setup_argumentsis_dataclass_prior_to_mappingallow_unmapped_annotationsFr=rr<rzDict[str, _CollectedAnnotation]rDict[str, Any]rrrrzutil.OrderedSet[Column[Any]]rzDict[Column[Any], int]rzRDict[Union[MappedColumn[Any], Column[Any]], Union[MappedColumn[Any], Column[Any]]]rz Optional[str]rMapping[str, Any]rr^rz&Optional[Callable[[], Dict[str, Any]]]rrrrzrrrr`rrrrrrrr\c sV|rt|ntj|_t|||||_d|_i|_i|_ t |_ i|_ i|_ d|_t|jdd|_}t|jddpBt|j|_t||_}t|d}|rU|r\|r\tdt|o`||_|||tj/t !|j"|j|j#|$||%|&|'||(||)|WddS1swYdS)NFra__allow_unmapped____sa_dataclass_metadata_key__zSQLAlchemy mapped dataclasses can't consume mapping information from dataclass.Field() objects if the immediate class is not already a dataclass.)*r0 immutabledictrrrrrrrr OrderedSetrrrrrrqrrzr dataclassesrrr~rrr_setup_declared_events_scan_attributes_setup_dataclasses_transformsrrrrrr_setup_inheriting_mapper_extract_mappable_attributes_extract_declared_columns _setup_table_setup_inheriting_columnsr) rQrrrrrdcacldsdkrrPrRrsT           "z_ClassScanMapperConfig.__init__rMrbcsTtjdrttdd fdd }tjdr(ttdd fd d }dSdS) Nreafter_configuredrMrbctdjdSN_DeclMappedClassProtocol[Any])rrqrerPrcrPrRrI zG_ClassScanMapperConfig._setup_declared_events..after_configuredrdbefore_configuredcrr)rrqrdrPrcrPrRrQrzH_ClassScanMapperConfig._setup_declared_events..before_configuredrf)r~rqr/ listens_forr')rQrrrPrcrRrFs    z-_ClassScanMapperConfig._setup_declared_eventsrqCallable[[str, Any], bool]csz|jr tdndsdfd d }|Sfd d tDfd d tDtdfdd }|S)zProduce a function that checks if a class has overridden an attribute, taking SQLAlchemy-enabled dataclass fields into account. rNkeyrGrrrMrzcst|||uSrO)r)rrrxrPrRattribute_is_overriddenhszR_ClassScanMapperConfig._cls_attr_override_checker..attribute_is_overriddenc$i|]}|jvr|j|jqSrPrZr.0fsa_dataclass_metadata_keyrPrR l   zE_ClassScanMapperConfig._cls_attr_override_checker..crrPrrrrPrRrqr cst|r|j}|}t|r|j}||urdS|ur dS|}t||}||ur2dS|ur=t|tr=dS||urCdS|urIdSdS)NFT)rfgetrrrr)rrret all_field)absentall_datacls_fieldsrqlocal_datacls_fieldsrPrRrys,    )rrGrrrMrz)rr~r0dataclass_fieldslocal_dataclass_fieldsr)rQrqrrP)r$r%rqr&rrR_cls_attr_override_checkerWs"9  (z1_ClassScanMapperConfig._cls_attr_override_checker>rKr[r_r]z ^(?:_sa_|__)rr2Callable[[], Iterable[Tuple[str, Any, Any, bool]]]cst|t||j|jfddtttD|jr*t|dnds9d fdd }|Sd d t |Dd fd d }|S) zproduce 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)rn)_include_dunders_match_exclude_dundersrPrR sz=_ClassScanMapperConfig._cls_attr_resolver..rNrM$Iterable[Tuple[str, Any, Any, bool]]csfddDS)Nc3s(|]}|||dfVqdS)FNr)rr)cls_annotationscls_varsrPrR s z`_ClassScanMapperConfig._cls_attr_resolver..local_attributes_for_class..rPrP)r2r3namesrPrRlocal_attributes_for_classs zM_ClassScanMapperConfig._cls_attr_resolver..local_attributes_for_classcSi|]}|j|qSrP)r)rfieldrPrPrRrsz=_ClassScanMapperConfig._cls_attr_resolver..c3sfD]-}|d}|r#|jvr#|jt|j|jdfVq|||dfVqdS)NTF)rrZr_as_dc_declaredattr)rr8)r2r3r'fixed_sa_dataclass_metadata_keyr5rrPrRr6s  )rMr0) r0get_annotationsvarsr-r.merge_lists_w_orderinglistrr~r()rQrqr6rP)r-r.r2r3r'r:r5rrR_cls_attr_resolvers.   "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}| ||||fq-| D]\}}}}| ||D]\}}}}||vr|dkrt |||}|s|r|rdfdd }|}qh|dkrt |||}| s|r|rj} qh|dkrt |||}|r| sdfd d }|} qh|d krt |||}|s|r|rj}t|tttdfstd ||urd}qhJ|rt|r|jstd|j|||fqh||urt|ttfrqht|trtdt|r|dusJ|jrF||vr1td||f| ||||<||<}t!|||n6|rZt"||d}t|t#sY|$}nt"||}t|t#rtt%|rtt|j&tst|j'}|||<||<t|ttfr|j(dur|j)|_(|*||+|d|qht,|||r| s||vs| |dsJqh|-|||qh|r||vs|||ur| ||rJt|r|$}|||<|*|||d|qh|*|||d|}|duo|j.du}|dur|j/n|}|dur| s|r|dur|nt||<qh||vr&|||<qhqY|r0| s0d}||_0| |_1||_2| |_3dS)NrrKr]rMrcs tjSrO)dictr]rP cls_as_DeclrPrR_mapper_args_fnAs z@_ClassScanMapperConfig._scan_attributes.._mapper_args_fnr[rCcsjSrO)rKrPrArPrR _table_fnWrz:_ClassScanMapperConfig._scan_attributes.._table_fnr_z3__table_args__ value must be a tuple, dict, or NoneTFzRegular (i.e. not __special__) attribute '%s.%s' uses @declared_attr, but owning class %s is mapped - not applying to subclass %s.zMapper 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)4rqrrrrr-r)rrr?_produce_column_copiesrupdaterr[r_rtupler@rr ArgumentErrorr_quietr0rrHr3r)r&rr__get__setattrrrr!roriginal_property descriptordocrW_collect_annotation_collect_return_annotationr+_warn_for_decl_attributesrrrrrr)rQrqrrrr-rrinherited_table_argsrr fixed_tablerbasesr class_mappedr6locally_collected_columnsrr annotationis_dataclass_field check_declrCrDr"collected_annotationr generated_objrPrArRrsv                             j z'_ClassScanMapperConfig._scan_attributesc s|j}|sdSdjjvrtdjddjjvr'tdjdttdfd d t j}|dus@Jfddfddj DD}rz D]\}}t j djdddd|Dd|ddddqZi}i}|D]#}t|dkr|\} } nt|dkr|\} } } | || <nJ| || <q| D] \} } tj| | q|j|dS)N__dataclass_fields__rz 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__' elementrrGrrrrMrzcs&|jurd|jvr||dS)Nr\T)rqrr)rr)rQwarn_for_non_dc_attrsrPrR_allow_dataclass_field:s  zT_ClassScanMapperConfig._setup_dataclasses_transforms.._allow_dataclass_fieldc s.g|]\}}}t|||j|tjqSrP)r!!_get_arguments_for_make_dataclassrrr2NO_ARG)rrannorrcrPrRr/HszH_ClassScanMapperConfig._setup_dataclasses_transforms..c 3sX|]'\}\}}}}}}}||r)|jvstj|ts||r$|n||fVqdSrO)rrr) rrraw_annor mapped_annois_dcrrr)r^rQrPrRr4Os.   zG_ClassScanMapperConfig._setup_dataclasses_transforms..zWhen transforming z to a dataclass, attribute(s) , cs|]}t|VqdSrOri)rrrPrPrRr4wz 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.0dcmxcoder.F)rrGrrrrMrz)rrqrrr collections defaultdictr>rrritemsr0warn_deprecatedjoinrrK_apply_dataclasses_to_any_class)rQrr field_listr non_dc_attrsrdefaultsitemrtpspeckvrP)r^rQr]rRrsb        '        z4_ClassScanMapperConfig._setup_dataclasses_transformsklass!Mapping[str, _AnnotationScanType]c Cslt|}i}|D](\}}t|||r/t|||j|tddddd}|r.|\}}|||<q |||<q |S)NFrequiredrX expect_mapped)r0r;ror+r*rUr) rqr{r2new_annorrW extractedinner_rPrPrR(_update_annotations_for_non_mapped_classs(    z?_ClassScanMapperConfig._update_annotations_for_non_mapped_classrguse_annotationsc Cs|||d}|tjurtj}|r t|dd}td||_nd}zBz||fidd|DWnt t fyR}zt j d|j d|dd d |d}~wwW|rc|dur^|`dS||_dSdS|rq|durn|`w||_w) NrorXrcSs(i|]\}}|tjur|dkr||qS)ro)r2r`)rryrzrPrPrRrs zJ_ClassScanMapperConfig._apply_dataclasses_to_any_class..zAPython dataclasses error encountered when creating dataclass for z: zN. Please refer to Python dataclasses documentation for additional information.dcterj)_assert_dc_argumentsr2r`r dataclassrrrXro TypeError ValueErrorrrrH)rqrr{rrorestoredexrPrPrRrrsL      z6_ClassScanMapperConfig._apply_dataclasses_to_any_class argumentscCsHhd}t||}|r"dddt|D}td|ddS)N>rjrhrirkrnrmrlrorecss|]}|VqdSrOrP)rargrPrPrRr4sz>_ClassScanMapperConfig._assert_dc_arguments..zDataclass argument(s) z are not accepted)set differencerqsortedrrH)rqralloweddisallowed_argsmsgrPrPrRrs  z+_ClassScanMapperConfig._assert_dc_argumentsrrGrr6rrOptional[bool]rrOptional[_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 | dddrpt|j| |j dd} t| try| }q]t|| | |||j ||j|<} | S)NFr}T) check_genericcheck_for_plain_string)include_generic)rrrrrFieldr$r*rqrUrr9r7r8r-r#found_in_pep593_annotatedr)rQrrrrrrallow_unmappedrXrrrelemcarPrPrRrOsj        z*_ClassScanMapperConfig._collect_annotationrrcCs,t|tjrtd|d|ddSdS)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. )rr1 ColumnElementr0r)rQrqrrrPrPrRrQBs z0_ClassScanMapperConfig._warn_for_decl_attributesattributes_for_classrrS0Dict[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 tfr|| | rWq|| | |d| } | durg| jn| } | |vrd|vr~t | ddpx| |dj vs| j r| j D]}|j dur|j jdurtdq| || <}||| <t|| |q|S)NTrKrzColumns 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:.)rqrrr+rOrr)rKrr3rr foreign_keys _table_columnrrr_copy)rQrrrSrrqrlocally_collected_attributesrrrrWrrZfkcopy_rPrPrRrEOsf           z-_ClassScanMapperConfig._produce_column_copiesc s|j}|j}|j}|j}t|ddd}|j}|p|j}t|j}t |D]:} | |vr,q$|| t rEj r?t d|jt|| nttr_j|ur_j| kr_tjt|| ttr{tdkr{tdttfr{t d| q$|rttjrq$tttfs|| ||| |st|| q$| dvrtd | d ttrt | |j!"ntt#r |j$"| d \} } } } }}}| dus| dus|rz%||j&||| | | | | Wnt'y}z t(d | d |d}~ww|s Jttr[j)rG|sGtt*r!gd}ngd}fdd|D}t(d| d|dd+t,dd|Ddtt*t-fs[|| t|| q$|| <q$dS)Nr{Tr|zUse of @declared_attr.cascading only applies to Declarative 'mixin' and 'abstract' classes. Currently, this flag is ignored on mapped class %srrzIgnoring 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.)rhdefault_factoryridefault)rhrrics(h|]}tjd|tjur|qS) dataclasses_)r_attribute_optionsr2r`rarrPrR Hs zF_ClassScanMapperConfig._extract_mappable_attributes..rrz# includes dataclasses argument(s): recsrfrOrgrrPrPrRr4TrhzF_ClassScanMapperConfig._extract_mappable_attributes..zF but class does not specify SQLAlchemy native dataclass configuration.).rqrrr-r~rrrzrr>rrr0rrrrrrr rKrGrr3r$rrr"poprQrr_undefer_column_namerrr#rrr NameErrorrH_has_dataclass_argumentsr&rqrr%)rQrqr our_stuffr- late_mappedrexpect_annotations_wo_mappedlook_for_dataclass_thingsryrWrrrrrrneargnamesargsrPrrRrs                       z3_ClassScanMapperConfig._extract_mappable_attributesc Cs2|j}|j}|j}tt}t|D]c\}}t|t rV|j }|r'|||<n||=|j D]'\}} t|t s>||j |||| ||<|durT||jkrT|||<q-qt|trw|j dusbJ||j |||||jkrw||=q|D]\} } t| dkrtd|j| dt| fq|dS)NrzzOn class %r, Column object %r named directly multiple times, only one will be used: %s. Consider using orm.synonym insteadre)rrrrmrnrr>rorr%mapper_property_to_assigncolumns_to_assignrraddrr3rr0rrrqr) rQrrrname_to_prop_keyrr mp_to_assigncol sort_orderrkeysrPrPrRrnsF         z0_ClassScanMapperConfig._extract_declared_columnsNcs|j}td|}|j}|j}|j}|j}|jt|}|j durd|vr|durt |dr:tt t t |j} nt } |durd} i} |rht|trN|} nt|trht|dtrf|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|std|jq||_dS)NMappedClassProtocol[Any]rK __table_cls__rPr__autoload_with__ autoload_with __autoload__Tautoloadcs |dS)Nrr1)rrrPrRs z5_ClassScanMapperConfig._setup_table..rz8Can't add additional column %r when specifying __table__)rqrrrrrrrrrrrr4r0unbound_method_to_callablerrr@rGrrr_metadata_for_clsrKrcontains_columnrrHrr)rQrrqrBrrrrr table_clsrtable_kwrrsorted_columnsrrPrrRr s             z#_ClassScanMapperConfig._setup_tablerClassManager[Any]rBcCs"t|jdd}|dur |S|jjS)NrZ)rrqrrZ)rQrmetarPrPrRrsz(_ClassScanMapperConfig._metadata_for_clscCs|j}|dd}|durAg}|jD]}t|}|durqt|r*||vr*||q|r@t|dkr.rz:mapper inherits argument given for non-inheriting class %sconcreteFexclude_propertiescsh|] }|jvr|jqSrP)_columntopropertyrrr)inherited_mapperrPrRrs  zC_ClassScanMapperConfig._prepare_mapper_arguments..rPcSsg|]}|jqSrPrrrPrPrRr/s)rrrFr@rrr0to_listrr'rrrrr,rrunionrdifference_updaterr>ror1r_propsr(columnscopyr) rQrrrryrz inherits_argrrrpresult_mapper_argsrP)rrQrR_prepare_mapper_argumentsgsj                 z0_ClassScanMapperConfig._prepare_mapper_argumentsrcCsP||t|jdrtdt|jj}nt}|d||j|j fi|j S)N__mapper_cls__zType[Mapper[Any]]rJ) rrrqrr0rrr'rrrrrPrPrRrs  z_ClassScanMapperConfig.map) rr=rrrr<rrrr\rf)rqrrMr)rqrrrMr*)r{rrMr|)rrgr{rrr|rMrb)rrgrMrb) rrGrr6rrrrrrrrMr)rqrrrrGrrrMrb) rr*rrrSrzrrrrMrrO)rrrMrb)rrrMrBrr)"rHrUrVr is_deferredrXrrr)r-recompiler.r?rrrrrrrrOrQrErrr rrr rr0rrrrPrPrrRrsh  M L   D 0x  4   J Z F ; N  ! HQrfield_metadatarrcCs2tjj}||}t|rt||js||S|SrO)r0rrcallablerr?)rrdecl_apirrPrPrRr9s  r9cseZdZUded<dZeZded<d$d d Ze d%d dZ e j d&ddZ e d'ddZ e d(ddZe d)ddZe d*ddZe d+d,dd Zejfd-fd"d# ZZS).ruweakref.ref[Type[Any]]_clsTz?util.OrderedDict[weakref.ref[Type[Any]], _DeferredMapperConfig]_configsrr\rMrbcCrNrOrPrrPrPrRrsz$_DeferredMapperConfig._early_mappingrrcCs|SrO)rrcrPrPrRrqsz_DeferredMapperConfig.clsrcCs t||j|_||j|j<dSrO)weakrefref_remove_config_clsrr)rQrrPrPrRrqsrcCs|j|ddSrO)rr)rqrrPrPrRrsz(_DeferredMapperConfig._remove_config_clsrzcCst|to t||jvSrO)rrrrrrqrrPrPrRrvsz_DeferredMapperConfig.has_clsr cCs.t|dr |tj|dt|dd)N_sa_raise_deferred_configrzG has a deferred mapping on it. It is not yet usable as a mapped class.)r)rrorm_excUnmappedClassError_safe_cls_namerrPrPrRraise_unmapped_for_clss z,_DeferredMapperConfig.raise_unmapped_for_clscCs|jt|SrO)rrrrrPrPrRrwsz$_DeferredMapperConfig.config_for_clsbase_clssortList[_DeferredMapperConfig]csrfdddd|jDD}|s|Sdd|Dg}D]|fddjDq tt||S)Ncs&g|]\}}|durt|r|qSrO)r)rmr)rrPrRr/ s z:_DeferredMapperConfig.classes_for_base..cSsg|]}||jfqSrPrxrrrPrPrRr/scSr7rPrxrrPrPrRrsz:_DeferredMapperConfig.classes_for_base..c3s(|]}|vr|fVqdSrOrP)rr) all_m_by_clsm_clsrPrRr4sz9_DeferredMapperConfig.classes_for_base..)rvaluesextendrr>r5r)rqrrclasses_for_basetuplesrP)rrrrRr  s  z&_DeferredMapperConfig.classes_for_basercs|j|jdt|SrO)rrrrrrrrPrRr!s z_DeferredMapperConfig.mapr)rMrr)rrrrMrb)rrrMrb)rrrrMrz)rrrrMr )rrrrMru)T)rrrrrzrMrr)rHrUrVrXrr0rrrpropertyrqsetterrrrvrrwr rrrrPrPrrRrus,        rurrMapperProperty[Any]rbcCs8d|jvrtd|}d dd}t|tr+t||||j|dd |j||d St|tr_|j }|j D]\}}t||||j|dd |sQ|j||q6|r]|j||d Sd St|t rm|j||d St|t r|j |krt|j }|j||d St||||jd St|||d S) zadd 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. rJrmcrMr4cSs&t|jtr |jStd|jd)Nz+Cannot add a new attribute to mapped class z) because it's not mapped against a table.)rrKr4rrrH)rrPrPrR_table_or_raise3s  z'_add_attribute.._table_or_raiseT)replace_existingN)rrrMr4)rrrr3rrrJ add_propertyr%rrr&rrr r __setattr___expire_memoizations)rqrr mapped_clsrmprrrPrPrR_add_attribute&s<        rcCsvd|jvr3||jvr3td|jjs3|j|}t|ttttfr#t dt ||td|j dSt ||dS)NrJrzrr?r@ sql.elementsrArBsql.selectablerCrDrGr\_TableArgsTyperFrYrgryrrr~rrrpreload_modulerrrrrrr9rurrrrHrrPrPrPrRs                                                                     '    Z>   M 4