oiLdZddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z mZddlmZddlmZmZmZmZmZmZmZmZddlmZmZdd lmZmZmZm Z m!Z!dd l"m#Z#d d l$m%Z%m&Z&d d l'm(Z(d dlm)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8m9Z9ddl:m;Z;mZ>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJddlKmLZLmMZMerd dlNmOZPd dlNmQZQmRZRd dlNmSZTd dlUmVZVneWZPeWZTeWjXZYGdd eZZ[d!d"dZd'Z\ed(Z]ed)ePeTe\f*Gd+d,e Z^d[d1Z_d\d7Z`d]d>Zad^dAZbd_dBZcd`dGZdd)d)ddHdadOZedbdPZfGdQdRZgGdSdTZhdcdWZidcdXZje dddYZkdS)ez"Private logic for creating models.) annotationsN)ABCMeta)cachepartialwraps) FunctionType) TYPE_CHECKINGAnyCallableGenericLiteralNoReturnTypeVarcast)PydanticUndefinedSchemaSerializer) TypeAliasTypedataclass_transform deprecatedget_args get_origin)typing_objects)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_namerebuild_model_fields)GenerateSchemaInvalidSchemaError)PydanticGenericMetadataget_model_typevars_map)import_cached_base_modelimport_cached_field_info)set_model_mocks) NsResolver)generate_pydantic_signature)_make_forward_refeval_type_backportis_classvar_annotationparent_frame_namespace)LazyClassAttributeSafeGetItemProxy)Field) FieldInfoModelPrivateAttr) PrivateAttr) BaseModelc$eZdZdZd fd ZxZS) _ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. kstrvobjectreturnNonec||d}|r@||urr>3sG))))))))))rUr>Finitr]Literal[False]rCr cdS)zOnly for typing purposes. Used as default value of `__pydantic_fields_set__`, `__pydantic_extra__`, `__pydantic_private__`, so they could be ignored when synthesizing the `__init__` signature. Nr\s rT NoInitFieldraCsrU_TT)kw_only_defaultfield_specifiersceZdZ d%d&fd Zesd'dZed(dZd)fd Ze j Z e j Z e d*dZ eeddd+d!Zed,d"Zd-fd$ ZxZS).ModelMetaclassNTcls_namer@basestuple[type[Any], ...] namespacedict[str, Any]__pydantic_generic_metadata__PydanticGenericMetadata | None#__pydantic_reset_parent_namespace__bool_create_model_module str | Nonekwargsr rCtypec  "#$|rtjdkr:d|vr |d}nCddlm} m} m} | |x} r| | | j}ni}n|di}||\} }}tj ||||}|j |d<t|||j || }|s|r=t||""!t"d6"fd }||d<n t |d<||d<i|||d<t#dt%j||||fi|}t)}|j}t,|vrT|t,||kr#t1jt5ddt7|jdd |_|j|jurdnd|_i|_ tCj"||_#|j#$||r ||_%n?t7|didd$t7|ddp$##r$rtM#fd$Dsddl'm(}tS$fd#D}|$vr<|#vr8d*d |D}|j+d!|d"|j+d#|d$}nm$|z}d*d%|D}d&|d'}d(|d)}t,|vr4d*d*|D|gz}|d+|j+d,|d-z }tY|dd#d.|_%d|_-|.D]\}}|/|||r tatc|_2t7|d/d}tg|thrtk|}tm|0} to||| 1d2|j#j8.D|_9|j:rtw|nty||| d|3|j=rd4|vrt}||t%||j?di||Sd5D]}!|@|!d|diAt%j||||fi|S)7aMetaclass for creating Pydantic models. Args: cls_name: The name of the class to be created. bases: The base classes of the class to be created. namespace: The attribute dictionary of the class to be created. __pydantic_generic_metadata__: Metadata for generic models. __pydantic_reset_parent_namespace__: Reset parent namespace. _create_model_module: The module of the class to be created, if created by `create_model`. **kwargs: Catch-all for any other keyword arguments. Returns: The new class created by the metaclass. )__annotations__r)Formatcall_annotate_function!get_annotate_from_class_namespace)format model_configNrQr<contextr rCrDc@t||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rQr}original_model_post_inits rTwrapped_model_post_initz7ModelMetaclass.__new__..wrapped_model_post_inits. 0g>>>00w?????rUmodel_post_init__class_vars____private_attributes__type[BaseModel]zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly.rrG__pydantic_base_init__Frl parametersr`__parameters__c3 K|]}|vV dSNr`).0xrs rT z)ModelMetaclass.__new__..s(?k?kTUZ?k?k?k?k?k?krU)RootModelRootTypec3$K|] }|v|V dSrr`)rrparent_parameterss rTrz)ModelMetaclass.__new__..s..c.cQQbHbHbqHbHbHbHb.c.crUz, cg|] }|j Sr`rVrrs rT z*ModelMetaclass.__new__..s3[3[3[1AJ3[3[3[rUzS is a subclass of `RootModel`, but does not include the generic type identifier(s) zL in its parameters. You should parametrize RootModel directly, e.g., `class z (RootModel[z ]): ...`.c,g|]}t|Sr`)r@rs rTrz*ModelMetaclass.__new__..s3X3X3XqCFF3X3X3XrUztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cg|] }|j Sr`rrs rTrz*ModelMetaclass.__new__..s2M2M2M!1:2M2M2MrUz- Note: `typing.Generic` must go last: `class (z): ...`))originargsr__pydantic_parent_namespace__)parent_namespace)config_wrapper ns_resolverc$i|] \}}||jSr`inforr?rAs rT z*ModelMetaclass.__new__..s-000"a16000rU) raise_errorscreate_model_module__hash__)__pydantic_fields_set____pydantic_extra____pydantic_private__rQr<r}r rCrD)Bsys version_info annotationlibrxryrz FORWARDREFrI_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrrrrO__new__r-__mro__r indexrKrLrgetattr__init____pydantic_custom_init__r__pydantic_post_init____pydantic_setattr_handlers__r!build__pydantic_decorators__update_from_configrlall root_modelrtuplejoinrV TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr5rrJdictunpack_lenient_weakvaluedictr0set_model_fieldscomputed_fields__pydantic_computed_fields__ defer_buildr/complete_model_classfrozenset_default_hash_func__pydantic_init_subclass__popclear)&mcsrgrhrjrlrnrprrraw_annotationsrxryrzannotatebase_field_names class_varsbase_private_attributesrprivate_attributesrcls BaseModel_mrormissing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrr instance_slotrrrrSs& @@@rTrzModelMetaclass.__new__Ss6 i N7**%22&/0A&BOOpooooooooo#D#DY#O#OOx-*@*@RXRc*d*d*d*,"+--0A2"F"FDGD[D[\aDbDb A j*A*4UIX^__N(6(BIn %!2?N,H*Vf"" " K%< K+>y%+P+P(+7344@@@@@54@4KI/003JI/0*4I& '2c5L2cPb2cI. /(/%''/#xPY*d*d]c*d*deeC133J+C#~~#))G"4"4syy7L7L"L"L 1B ! 07s|E]_d/e/e+eC (+z/IIIO`  &13C -*8*>s*C*CC '  ' : :> J J J-. 4Q11$+C1PRT$U$U$Y$YZfhj$k$k!$S*:DAAVEV #3"3#3C?k?k?k?kYj?k?k?k>>>>>)..c.c.c.c*.c.c.c)c)c&(,===BS[eBeBe*.3[3[HZ3[3[3[)\)\"|JJ-JJWZWcJJp~JJJ& /@BT.T+)-3X3XDW3X3X3X)Y)Y-P~-P-P-P*N8JNNN&#%// )- 2M2Mu2M2M2MQcPd2d(e(eI) rPSP\ r r_h r r rM$M222#",551 ).C %05577 , , c  d++++2 j4OPfPhPh4i4i16=cCbdh6i6i *D11 R#?@P#Q#Q $6FGGGK S[ Y Y Y Y00&)&A&Q&W&W&Y&Y000C ,) $$$$%"!&(< $ 29)D)D%c5111 7E#sOO 6 @ @ @ @ @J"i    ! MM+R 0 0 6 6 8 8 8"577?3%MMfMM MrUitemcp|jd}|r ||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.r)__dict__rIAttributeError)rQrrs rT __getattr__zModelMetaclass.__getattr__sE!%!2!23K!L!L ! 0d.@&@&@)$// && &rUrdict[str, object]ctSr)r>)rrrrs rT __prepare__zModelMetaclass.__prepare__#s"$$$rUsubclasstype[_T]ctjd|jddt|S)Nz>For performance reasons, virtual subclasses registered using 'zK.register()' are not supported in 'isinstance()' and 'issubclass()' checks.rrG)rKrLrXrOregister)rQrrSs rTrzModelMetaclass.register+sV  MTM^ M M M    ww)))rU6tuple[set[str], set[str], dict[str, ModelPrivateAttr]]cjt}t}t}i}|D]}t||rn||urj|t |di||j||j|||fS)N__pydantic_fields__)r-set issubclassupdaterkeysrr)rhr< field_namesrrbases rTrz"ModelMetaclass._collect_bases_data6s,.. # "uu :< G GD$ ** Gt9/D/D""741F#K#K#P#P#R#RSSS!!$"5666"))$*EFFFJ(:::rUXThe `__fields__` attribute is deprecated, use the `model_fields` class property instead.)categorydict[str, FieldInfo]c\tjdtdt|diS)NrrrGr)rKrLrrrQs rT __fields__zModelMetaclass.__fields__Es;  f %    t2B777rUcd|jvrdStd|j}td|DS)zWhether the fields where successfully collected (i.e. type hints were successfully resolves). This is a private attribute, not meant to be used outside Pydantic. rFrc3$K|] }|jV dSr) _complete)r field_infos rTrz>ModelMetaclass.__pydantic_fields_complete__..\s%OOJ:'OOOOOOrU)rrrrvalues)rQ field_infoss rT__pydantic_fields_complete__z+ModelMetaclass.__pydantic_fields_complete__QsR ! 5 55143KLL OO+:L:L:N:NOOOOOOrU list[str]ctt}d|vr|d|S)Nr)listrO__dir__remove)rQ attributesrSs rTrzModelMetaclass.__dir__^sC%''//++,, : % %   l + + +rU)NTN)rgr@rhrirjrkrlrmrnrorprqrrr rCrs)rr@rCr )rr rrr rCr)rrrCr)rhrirCr)rCr)rCro)rCr )rVrWrXrr r classmethodrrrs__instancecheck____subclasscheck__ staticmethodrpropertyrrr rrZr[s@rTrfrfQsrIM48+/DNDNDNDNDNDNDNL ' ' ' ' '%%%[%******.. ; ; ;\ ;Zbmq888X8 P P PX PrUrfrQr<r}rDct|ddVi}|jD]'\}}|}|tur|||<(t |d|dSdS)a This function is meant to behave like a BaseModel method to initialise private attributes. It takes context as an argument since that's what pydantic-core passes when calling it. Args: self: The BaseModel instance. context: The context. rN)rrr get_defaultrobject_setattr)rQr}pydantic_privater private_attrdefaults rTrrest+T22:"&"="C"C"E"E 1 1 D,"..00G///)0 &t35EFFFFF ;:rUrjrkrhriCallable[..., Any] | Nonecpd|vr|dSt}t|d}||jur|SdS)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rN)r-r#r)rjrhr<rs rTrrwsPI%%*++(**I.u6GHHOi77787rUrrbase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c nddlmm}t}|t z}i}d|vsd|vrt dt } t|D]\} } | dks| dkrt| tr9| j |dkr(d|vr$| j |dd rat| |s| jj d kr| | t| rZ| d rt!d | d t#| rt!d d| zd| d | || <|| =t| |rFields must not use names with leading underscores; e.g., use )rzField z defined on a base class was overridden by a non-annotated attribute. All field definitions, including overrides, require a type annotation.zmodel-field-overridden)codez requires a type annotationzmodel-field-missing-annotationz)A non-annotated attribute was detected: `z = z3`. All model fields require a type annotation; if `z` is not meant to be a field, you may be able to resolve this error by annotating it as a `ClassVar` or updating `model_config['ignored_types']`.NFT) is_argumentis_class)globalnslocalnsc3<K|]}t||VdSr)rJ)rrAr:s rTrz$inspect_namespace..s3$\$\1JqJZ<[<[$\Q$\$\$\$\$\$\rU)$fieldsr:r;r.default_ignored_typesrrr rrJrsrWrX startswithrSadd NameErrorr&lstripr'r4rrrr@r _getframer3r2 f_globalsf_localsr is_annotatedrrnext)rjrrrr r;r9all_ignored_typesr ignored_namesvar_namevaluesuggested_nameann_nameann_typeframer&metadatarr:s @rTrrsb876666666(**I%(=(?(??68_$$ i(?(?oppp!eeM  1 122;;% ~ % %5I)I)I  ud # #8  Il$;;;)++"-->1J.M.M.MNN,  0 1 10 U_5OS^5^5^   h ' ' '  / 0 0- ""4(( PBJPPP%X.. [/2X~[[MU[[[,1 x ((## y ) ) 2Eh2O2O %__S11?ZNJ,JJz make_hash_func..slmrUrQr rCintc t|jS#t$r-tt|jcYSwxYwr)hashrKeyErrorr7)rQgetters rT hash_funcz!make_hash_func..hash_funcsm At}--.. . A A A / >>??@@ @ @ @  As 4AA)rQr rCrJ)roperator itemgetterr)rrOrNs @rTrDrDs\EHE\ mX #"9">">"@"@ A AbmbmFAAAAAA rUrr rNsResolver | Nonect|}t||||\}}||_|j||D]C}|j|d}|$|jturt|||jDdS)zCollect and set `cls.__pydantic_fields__` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting model annotations. ) typevars_mapN) r,r%rrrrrrrsetattr)rrrrTr.rr?r<s rTrr)s*#..L-c>;]ijjjFJ$Cj)))  + +*..q$77  6G!G!G CEM * * * + +rU)rcall_on_complete_hookrr0rrorVrrqc Dt|}|jsw t|||||_nI#t$r<}t j|}t|d|jd|r||Yd}~nd}~wwxYw|s |jsdS|jsJt|||} | |} n4#t $r'}|rt|d|jdYd}~dSd}~wwxYw| |j } | | } n #t$rt|YdSwxYwd|jjD|_t'|| |_t+| ||p|j|j|rdnd| |j|_t5| | |_t9d t;t<|j|j|j |j! |_"d |_#|r|$d S) aKFinish building a model class. This logic must be called after class has been created since validation functions must be bound and `get_type_hints` requires a class object. Args: cls: BaseModel or dataclass. config_wrapper: The config wrapper instance. ns_resolver: The namespace resolver instance to use during schema building. raise_errors: Whether to raise errors. call_on_complete_hook: Whether to call the `__pydantic_on_complete__` hook. create_model_module: The module of the class to be created, if created by `create_model`. Returns: `True` if the model is successfully completed, else `False`. Raises: PydanticUndefinedAnnotation: If `PydanticUndefinedAnnotation` occurs in`__get_pydantic_core_schema__` and `raise_errors=True`. )rrrTrFNF)titlec$i|] \}}||jSr`rrs rTrz(complete_model_class..s 'r'r'rda16'r'r'rrU create_modelr< __signature__)r]r.validate_by_nameextraT)%r,r r(rr2rfrom_name_errorr/rr)generate_schema core_configrV clean_schemar*rrrrset_deprecated_descriptors__pydantic_core_schema__rrWrXplugin_settings__pydantic_validator__r__pydantic_serializer__r6rr1rr\r]r[r__pydantic_on_complete__) rrrrrVrrTeexc gen_schemaschemar`s rTrrHs:*#..L  +0 !&:-') '''C # #  ! ! !-=a@@C CSX 1 1 1 !q  ! ! ! ! ! !  C$D 5////J ++C00 &   ]]]]+++uuuuu  !,,3<,@@K((00 uu (s'rc>Y>i>o>o>q>q'r'r'rC$s####)C !8 -s~ ->;&""C#36;"G"GC + '*+< &      C!%C' $$&&& 4s>1 A72A22A7 B66 C'C""C'DD98D9c|jD]D\}}|jx}6t|}|||t |||E|jD]l\}}|jx}^tt|j ds-c22D   c5 ) ) ) C % % %&)&F&L&L&N&N&&""'; ;S H34G4XYY[kll I.c3F3WXXD   c5 ) ) ) C % % %&&rUcBeZdZUdZded<ddd ZddZdddZddZdS)roaWRead-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field. Attributes: msg: The deprecation message to be emitted. wrapped_property: The property instance if the deprecated field is a computed field, or `None`. field_name: The name of the field being deprecated. r@ field_nameNrsrqproperty | NonerCrDc"||_||_dSr)rsrq)rQrsrqs rTrz#_DeprecatedFieldDescriptor.__init__s 0rUrrrc||_dSr)rw)rQrrs rTrz'_DeprecatedFieldDescriptor.__set_name__s rUrBaseModel | Noneobj_typetype[BaseModel] | Noner c|6|j|jd|St|jt j|jtd|j|j||S|j|jS)NrrG) rq__get__rrwrKrLrsDeprecationWarningr)rQrr|s rTrz"_DeprecatedFieldDescriptor.__get__s ;$0,44T8DDD 11 1 dh 2qAAAA  ,(00h?? ?|DO,,rUr<rc*t|jr)rrw)rQrr<s rT__set__z"_DeprecatedFieldDescriptor.__set__sT_---rUr)rsr@rqrxrCrD)rrrr@rCrD)rr{r|r}rCr )rr r<r rCr) rVrWrXrYrwrrrrr`rUrTrorosOOO11111 - - - - -......rUroc*eZdZdZd dZd dZd dZd S) _PydanticWeakRefaWrapper for `weakref.ref` that enables `pickle` serialization. Cloudpickle fails to serialize `weakref.ref` objects due to an arcane error related to abstract base classes (`abc.ABC`). This class works around the issue by wrapping `weakref.ref` instead of subclassing it. See https://github.com/pydantic/pydantic/issues/6763 for context. Semantics: - If not pickled, behaves the same as a `weakref.ref`. - If pickled along with the referenced object, the same `weakref.ref` behavior will be maintained between them after unpickling. - If pickled without the referenced object, after unpickling the underlying reference will be cleared (`__call__` will always return `None`). rr cN| d|_dStj||_dSr)_wrweakrefref)rQrs rTrz_PydanticWeakRef.__init__ s) ;DHHH{3''DHHHrUrCc<|jdS|Sr)rrs rT__call__z_PydanticWeakRef.__call__s 8 488:: rU4tuple[Callable, tuple[weakref.ReferenceType | None]]c&t|ffSr)rrs rT __reduce__z_PydanticWeakRef.__reduce__s$$&&**rUN)rr )rCr )rCr)rVrWrXrYrrrr`rUrTrrsZ (((( ++++++rUrddict[str, Any] | Nonec|dSi}|D]-\}} t|}n#t$r|}YnwxYw|||<.|S)aXTakes an input dictionary, and produces a new value that (invertibly) replaces the values with weakrefs. We can't just use a WeakValueDictionary because many types (including int, str, etc.) can't be stored as values in a WeakValueDictionary. The `unpack_lenient_weakvaluedict` function can be used to reverse this operation. N)rrr)rresultr?rAproxys rTrrsv yt F 1 $Q''EE   EEE q Ms1 AAc|dSi}|D]1\}}t|tr|}||||<,|||<2|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrJr)rrr?rAs rTrr/siyt F 1 a) * * A}q F1II MrUcddlm}tttt t |tg}tj dkr| tjt|S)Nr)ComputedFieldInfo)ru ) r.rrrrrr"rrrappendtypingr)rrs rTr/r/?sg****** M 7""V1222   rU)r]r^rCr r)rjrkrhrirCr) rjrkrrkrrirrr rrCr!)rrrhrirCrD)rrrCr )rrrr rrRrCrD)rrrr rr0rrorVrorrqrCro)rrrCrD)rrrCr)rCri)lrY __future__r _annotationsrPrrrKrabcrr$rrrtypesrr r r r r rrr pydantic_corerrtyping_extensionsrrrrrtyping_inspectionrerrorsrrplugin._schema_validatorrrr_configr _decoratorsr!r"r#r$_fieldsr%r&r'r(_generate_schemar)r* _genericsr+r, _import_utilsr-r. _mock_val_serr/_namespace_utilsr0 _signaturer1 _typing_extrar2r3r4r5_utilsr6r7r.r8PydanticModelFieldr9r:r;PydanticModelPrivateAttrmainr<rB __setattr__rrr>rarbrfrrrrrDrrrbrorrrr/r`rUrTrs&((222222 ++++++++++ZZZZZZZZZZZZZZZZZZZZ========bbbbbbbbbbbbbb,,,,,,CCCCCCCC>>>>>>OOOOOOOO""""""ssssssssssssoooooooooooo@@@@@@@@FFFFFFFFMMMMMMMM******((((((333333 98888888(44444444444444@@@@@@       %vxx# ) ) ) ) )$ ) ) )$! WT]]T=OQikv