RPf-|dZddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZmZmZmZddlZddlmZmZdd lmZmZd d lmZmZd d lmZd d lmZmZddl m!Z!ddl"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;ddlZ>ddl?m@Z@ejrd dlBmCZDd dlBmEZEmFZFd dlGmHZHn eZIeJZDeJjZLGddeMZNedeDf Gd!d"e ZOd3d#ZPd4d$ZQ d5d%ZRd6d&ZSd7d'ZT d8d(ZUddd) d9d*ZVd:d+ZWGd,d-ZXGd.d/ZYd;d0ZZd;d1Z[dstrr?objectreturnNone)__name__ __module__ __qualname____doc__r< __classcell__rAs@rBr2r2.s))rCr2T)kw_only_defaultfield_specifiersceZdZ d d fd Zej sd dZeddZdfd Z e ddZ e e dddd Zdfd ZxZS)ModelMetaclassNc  !|r|j|\}} } tj|||} | j|d<t || j | |} | s| r#t || d$fd } | |d<n t|d<| |d<i| | |d<t"|$||||fi|}ddl m }|j}t|vrG|jt|j|kr tj t#d d t%|j&d d  |_|j*|j*urdnd|_t/j0||_|r ||_n[t%|d ij7dd!t%|ddxs! r!rt9 fd!Dsddlm}t?!fd D}|!vrZ| vrVdjA|Dcgc]}|jBc}}|jBd|d|jBd|d}tG|!|z}djA|Dcgc] }tE|c}}d|d}d|d}t|vrCdjA|Dcgc]}|jBc}|gz}|d|jBd|dz }tG|dd d |_d |_$| jKD]\}}|jM|||rtOtQ|_)t%|d!d}tU|tVr tY|}t[||}t]||| || j^rd"|vr ta||tc||| d ||#|j2jdjKDcic]\}}||jfc}}|_4tk|t||di||St"|$||||fi|Scc}wcc}wcc}wcc}}w)%aMetaclass 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. model_configNc0t||||y)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)r=_ModelMetaclass__contextoriginal_model_post_inits rBwrapped_model_post_initz7ModelMetaclass.__new__..wrapped_model_post_inites0i@0yArCmodel_post_init__class_vars____private_attributes__rr/zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly. stacklevel__pydantic_base_init__F__pydantic_generic_metadata__ parameters__parameters__c3&K|]}|v ywNra).0xr`s rB z)ModelMetaclass.__new__..s?kTUZ?ks)RootModelRootTypec3,K|] }|vs| ywrdra)rerfparent_parameterss rBrgz)ModelMetaclass.__new__..s.cQQbHbq.cs z, zS 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 ]): ...`.ztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .z- Note: `typing.Generic` must go last: `class (z): ...`))originargsr`__pydantic_parent_namespace____hash__) raise_errorstypes_namespacecreate_model_module)r=r0rVrrFrG)7_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrUr;__new__mainr0__mro__r indexr7r8rgetattr__init____pydantic_custom_init__rY__pydantic_post_init__rbuild__pydantic_decorators__r_r5all root_modelrhtuplejoinrHrD TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr(rpr6dictunpack_lenient_weakvaluedictr%set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fieldsinfomodel_computed_fieldsset_deprecated_descriptors__pydantic_init_subclass__)#mcscls_namebases namespacer_#__pydantic_reset_parent_namespace___create_model_modulekwargsbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrXclsr0mrorhmissing_parametersrfparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjparent_namespacersr>r?rWr`rjrAs# @@@rBr{zModelMetaclass.__new__=sz6 DGD[D[\aDb A j*A*44UIvNN(6(B(BIn %!2>77EU" "%<+>y%+P(+7B4KI/03JI/0*4I& '2c5L2cPb2cI. /#(7?3%#]V\#]C (++C#~#))G"4syy7K"K 1B ! 07s||E]_d/e+eC (141D1D HaHa1agxC &*8*>*>s*CC '-4Q1$+C1PRT$U$Y$YZfhj$k!$S*:DAVEV "3C?kYj?k)..c*.c)c&(,==BS[eBe*.HZ3[1AJJ3[)\"||n,-./WWZWcWcVddop~o@IJ&,$M22!/@BT.T+)-DW3XqCF3X)Y/>~>Na-P*88J7K1N&#%/ )- u2M!1::2MQcPd2d(eI)"OPSP\P\~]^_h^iiq rM$M22#",51 ).C %0557 , c  d+ ,34OPfPh4i1&s,KTR *D1#?@P#Q 5c;KLO S% I$$9)D%c51 " /$8  @C?Z?Z?j?j?p?p?r(stq!AFF(sC % &s + #s 6 @ @J7?3%MfM MQ4\4Y3NT)ts!O2<O78O<#Pc|jjd}|r ||vr||S|dk(r;t|dd}t|tr|j }| t|dSt |)zNThis is necessary to keep attribute access working for class attribute access.r[__pydantic_core_schema____pydantic_validator__N)__dict__r5rr6r!rebuildAttributeError)r=itemrmaybe_mock_validatorrebuilt_validators rB __getattr__zModelMetaclass.__getattr__s!%!2!23K!L !d.@&@)$//11'.t5Mt'T$2J?(<(D(D(F%(4&t-GHH & &rCctSrd)r2)rrors rB __prepare__zModelMetaclass.__prepare__s "$$rCc>t|dxrt| |S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 r)hasattrr;__instancecheck__)r=instancerAs rBrz ModelMetaclass.__instancecheck__s# x!9:buw?XYa?bbrCc6ddlm}t}t}i}|D]t}t||s||us|j t |dij |j |j|j |jv|||fS)Nrr/ model_fields) r|r0set issubclassupdaterkeysrZr[)rr0 field_namesrrbases rBruz"ModelMetaclass._collect_bases_datas$ # "u :< GD$ *t9/D""74#D#I#I#KL!!$"5"56"))$*E*EF  G J(:::rCEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorycNtjdt|jS)Nr)r7r8rrr=s rB __fields__zModelMetaclass.__fields__s$  SUn    rCc`tt| }d|vr|jd|S)Nr)listr;__dir__remove)r= attributesrAs rBrzModelMetaclass.__dir__s0%'/+, : %   l +rC)NTN)rrDrtuple[type[Any], ...]rdict[str, Any]r_zPydanticGenericMetadata | Nonerboolr str | NonerrrFtype)rrDrFr)rorrrrFzdict[str, object])rrrFr)rrrFz6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rFzdict[str, FieldInfo])rFz list[str])rHrIrJr{typing TYPE_CHECKINGr classmethodrr staticmethodrupropertyrrrrLrMs@rBrQrQ;sIM48+/cNcN%cN" cN (F cN .2 cN)cNcN cNJ    '%%c ; ;Wbfg!h! rCrQct|ddPi}|jjD]#\}}|j}|tus|||<%t |d|yy)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. __pydantic_private__N)rr[r get_defaultr object_setattr)r= __contextpydantic_privater private_attrdefaults rBrUrUstt+T2:"&"="="C"C"E 1 D,"..0G//)0 & 1 t35EF ;rCcZd|vr|dSddlm}t|d}||jur|Sy)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.rYrr/N)r|r0rrY)rrr0rYs rBrzrz/s?I%*++ .u6GHOi7778rCc fddlm}mm}|t z}i}|j di}d|vsd|vr t dt} t|jD]\} } | dk(r t| tr5| j|dk(r#d|vr| jj|drRt| |s| jjd k(r| j!| t| rI| jd rt#d | d t%| rt#d d| zd| d | || <|| =t| |r2t%| s'| j'dxsd} t#d| d| d | jd r/t)| r%| |vst+|| rN|| || <|| =_| |vre| |vsk| |vrt-d| ddt| |rt-d| ddt-d| d| d| dd|jD]\} }t)| s| |vs| | vst+|r(||vs-t/|ddd k7s>t1|r4t3j4|^}}t7fd|Dd}|||| <}||| <|S)aIterate over the namespace and: * gather private attributes * check for items which look like fields but are not (e.g. have no annotation) and warn. Args: namespace: The attribute dictionary of the class to be created. ignored_types: A tuple of ignore types. base_class_vars: A set of base class class variables. base_class_fields: A set of base class fields. Returns: A dict contains private attributes info. Raises: TypeError: If there is a `__root__` field in model. NameError: If private attribute name is invalid. PydanticUserError: - If a field does not have a type annotation. - If a field on base class was overridden by a non-annotated attribute. r)r-r. PrivateAttr__annotations____root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rSrIrJ functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rlzJPrivate attributes must not use valid field names; use sunder names, e.g. _z instead of my_fieldz>Fields 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']`.Nc3<K|]}t|s|ywrd)r6)rer?r.s rBrgz$inspect_namespace..s$\1JqJZ<[Q$\s)fieldsr-r.rdefault_ignored_typesr5rrrrr6rrIrJ startswithrAadd NameErrorrlstriprr'rrr&typing_extensionsget_argsnext)rrybase_class_varsbase_class_fieldsr-rall_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typermetadatarr.s @rBrxrx;sY4BA%(=(??68mm$5r:O_$ i(?opp!eM  12;% ~ %  ud #  Il$;;)+""--i.GH  0 1U__5O5OS^5^   h '  / 0""4(BBJQP%X.//2X~.@ XLXY[,1 x ((# y )2Eh2O%__S1?ZN,/|Hz make_hash_func..srCc t|jS#t$r'tt|jcYSwxYwrd)hashrKeyErrorr*)r=getters rB hash_funcz!make_hash_func..hash_funcsJ At}}-. . A / >?@ @  As-A A)r=rrFint)roperator itemgetterr)rrrs @rBrrs;>A>N>NX #"2"2"7"7"9 :T_FA rCc$t|}t|||||\}}||_|jj ||D]K}|j j |d}|"|jtus5t|||jMy)a.Collect and set `cls.model_fields` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. bases: Parents of the class, generally `cls.__bases__`. config_wrapper: The config wrapper instance. types_namespace: Optional extra namespace to look for types in. ) typevars_mapN) r rrrZrr[poprr setattr) rrrrsrrrr>rs rBrrs*#.L-c5./htuFJCj)  +**..q$7  6G!G CEMM * +rC)rrrtc t|}t|||}tt|jd|d}|j r t ||y |j||} |j|} |j| } | |_ t| ||xs |j|j |rdnd| |j"|_t'| | |_d |_t-d t/|j0|j2| |_y #t$r(} |rt ||d| jdYd} ~ yd} ~ wwxYw#|j$rt ||YywxYw) aFinish 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. cls_name: The model or dataclass name. config_wrapper: The config wrapper instance. raise_errors: Whether to raise errors. types_namespace: Optional extra namespace to look for types in. 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`. F)from_dunder_get_core_schemaunpack)ref_moder4N create_modelr0T __signature__)initrr)r rr#rgenerate_schema defer_buildr"__get_pydantic_core_schema__rr core_config clean_schemaCollectedInvalidrrrIrJplugin_settingsrr __pydantic_serializer__rr)r$rrr) rrrrrrsrtr gen_schemahandlerschemaer!s rBrrs|:*#.LJ + **NG !!X&11#w?!,,S1K((0 $*C !8 -s~~ -;&&"C#36;"GC $C'#c>N>N_mnC E '  X166(!}5   & &X&s*D:E  E !EE  E*)E*c|jjD]>\}}|jx}t|}|j ||t |||@|j jD]i\}}|jx}tt|jdr5t||j}|j ||t |||ky)z8Set data descriptors on the class for deprecated fields.N__deprecated__) rrdeprecation_message_DeprecatedFieldDescriptorrrrrrwrapped_property)rfield field_infomsgdesccomputed_field_infos rBrrAs --335&z11 1C >-c2D   c5 ) C % & '*&?&?&E&E&G&""';; ;S H34G4X4XY[kl-c3F3W3WXD   c5 ) C %&rCc@eZdZUdZded<d d dZd dZd d dZd dZy)r-aMData 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. rD field_nameNc ||_||_yrd)r1r.)r=r1r.s rBrz#_DeprecatedFieldDescriptor.__init___s 0rCc||_yrd)r5)r=rrs rBrz'_DeprecatedFieldDescriptor.__set_name__cs rCc|t|jtj|jt j d|j|jj||S|j|jS)Nrr\) rr5r7r8r1builtinsDeprecationWarningr.__get__r)r=robj_types rBr;z"_DeprecatedFieldDescriptor.__get__fsh ; 1 1 dhh ; ;J  ,((00h? ?||DOO,,rCc,t|jrd)rr5)r=rrs rB__set__z"_DeprecatedFieldDescriptor.__set__ssT__--rCrd)r1rDr.zproperty | NonerFrG)rtype[BaseModel]rrDrFrG)rzBaseModel | Noner<ztype[BaseModel] | NonerFr)rrrrrFr ) rHrIrJrKrrrr;r>rarCrBr-r-Ts"O1-.rCr-c(eZdZdZddZddZddZy) _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`). cL|d|_ytj||_yrd)_wrweakrefref)r=rs rBrz_PydanticWeakRef.__init__s ;DH{{3'DHrCc<|jy|jSrd)rCrs rB__call__z_PydanticWeakRef.__call__s 88 88: rCct|ffSrd)rArs rB __reduce__z_PydanticWeakRef.__reduce__s$&**rCN)rr)rFr)rFz4tuple[Callable, tuple[weakref.ReferenceType | None]])rHrIrJrKrrGrIrarCrBrArAws ( +rCrAc|yi}|jD]\}} t|}|||<|S#t$r|}YwxYw)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)rrAr)dresultr>r?proxys rBrrsa y F 1 $Q'Eq  M E s 1 ??c|yi}|jD]*\}}t|tr|}| |||<&|||<,|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr6rA)rKrLr>r?s rBrrsXy F 1 a) *A}q F1I  MrCcPddlm}tttt t |tfS)NrComputedFieldInfo)rrQrrrrrr+rPs rBrrs&*  rC)r=r0rrrFrG)rrrrrFzCallable[..., Any] | None) rrryrrset[str]rrRrFzdict[str, ModelPrivateAttr])rr?rrrFrG)rr?rFr) rr?rrrrrsrrFrG)rr?rrDrrrrrrsdict[str, Any] | NonertrrFr)rr?rFrG)rKrSrFrS)rFr)]rK __future__r _annotationsr9rrr7rDabcrrrtypesrrrr r r pydantic_corer r r rerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsrrr_generate_schemar _genericsrr _mock_val_serr!r"_schema_generation_sharedr# _signaturer$ _typing_extrar%r&r'r(_utilsr)r*_validate_callr+rrr,PydanticModelFieldr-r.r|r0r:rE __setattr__rrr2rQrUrzrxrrrrrr-rArrrrarCrBrhs(2 33==C>O"ssYY,F6C3ee4/ 44 3## )$ )T=O