TgPdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddlmZddlmZmZmZmZmZmZddlmZmZdd lmZmZmZmZd d lm Z m!Z!d d l"m#Z#d d lm$Z$m%Z%ddl&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBmCZCmDZDmEZEmFZFddlGmHZHmIZIejJrd dlKmLZLmMZMmNZNd dlKmOZPd dlKmQZRd dlSmTZTne%ZUeVZPeVZReVjWZXGdd eYZZd!d"dYd'Z[ed(ePeRe[f)Gd*d+e Z\dZd0Z]d[d6Z^d\d<Z_d]d?Z`d^d@Zad_dEZbd(dddFd`dMZcdadNZdGdOdPZeGdQdRZfdbdUZgdbdVZhe dWdcdXZidS)dz"Private logic for creating models.) annotationsN)ABCMeta) lru_cachepartial) FunctionType)AnyCallableGenericLiteralNoReturncast)PydanticUndefinedSchemaSerializer) TypeAliasTypedataclass_transform deprecatedget_args)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_name)GenerateSchema)PydanticGenericMetadataget_model_typevars_map)import_cached_base_modelimport_cached_field_info)set_model_mocks) NsResolver)CallbackGetCoreSchemaHandler)generate_pydantic_signature)_make_forward_refeval_type_backport is_annotatedis_classvar_annotationparent_frame_namespace)LazyClassAttributeSafeGetItemProxy)ComputedFieldInfo FieldInfoModelPrivateAttr)Field) 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>||ur:t|tr%tjd|d|jjdt||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarndecorator_infodecorator_reprsuper __setitem__)selfr;r=existing __class__s [/var/www/sysmax/venv/lib/python3.11/site-packages/pydantic/_internal/_model_construction.pyrJz_ModelNamespaceDict.__setitem__=s}D))  x))jCZ.[.[) Mvavv8CZCivvv w w www""1a((()r;r<r=r>r?r@)__name__ __module__ __qualname____doc__rJ __classcell__rMs@rNr:r:8sG))))))))))rOr:FinitrWLiteral[False]r?rcdS)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. NrVs rN NoInitFieldr[EsrOT)kw_only_defaultfield_specifiersceZdZ d&d'fd Zejsd(dZed)dZd*fd Z e d+dZ e e ddd,d Ze d,d!Ze d-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 | Nonekwargsrr?typec |r||\}} } tj|||} | j|d<t || j| |} | s| r(t || d1fd } | |d <n t|d <| |d <i| | |d <td tj ||||fi|}t}|j }t|vrT|t||kr#tjt#ddt%|jdd |_|j|jurdnd |_t/j||_|r ||_n?t%|diddt%|ddprrt9fdDsddlm}t?fdD}|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 }tE|ddd)|_d|_#| $D]\}}|%|||r tMtO|_(t%|d*d}tS|tTrtW|}tY|+}t[||| || j.rd,|vrt_||ta||| d||-d.|jj1$D|_2tg|t||j4di||Sd/D]}|5|d|d0i6tj ||||fi|S)2aMetaclass 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_configNrKr8contextrr?r@c@t||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rKrooriginal_model_post_inits rNwrapped_model_post_initz7ModelMetaclass.__new__..wrapped_model_post_initys.0g>>>00w?????rOmodel_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.r stacklevel__pydantic_base_init__Fre parametersrZ__parameters__c3 K|]}|vV dSNrZ).0xr{s rN z)ModelMetaclass.__new__..s(?k?kTUZ?k?k?k?k?k?krO)RootModelRootTypec3$K|] }|v|V dSr~rZ)rrparent_parameterss rNrz)ModelMetaclass.__new__..s..c.cQQbHbHbqHbHbHbHb.c.crOz, cg|] }|j SrZrPrrs rN z*ModelMetaclass.__new__..s3[3[3[1AJ3[3[3[rOzS 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|SrZ)r<rs rNrz*ModelMetaclass.__new__..s3X3X3XqCFF3X3X3XrOztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cg|] }|j SrZrrs rNrz*ModelMetaclass.__new__..s2M2M2M!1:2M2M2MrOz- Note: `typing.Generic` must go last: `class (z): ...`))originargsr{__pydantic_parent_namespace__)parent_namespace__hash__ raise_errors ns_resolvercreate_model_modulec$i|] \}}||jSrZ)info)rr;r=s rN z*ModelMetaclass.__new__..s-000"a16000rO)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rKr8rorr?r@)7_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrqr rI__new__r&__mro__r indexrErFrgetattr__init____pydantic_custom_init__rt__pydantic_post_init__rbuild__pydantic_decorators__rerCall root_modelrtuplejoinrP TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr0rrDdictunpack_lenient_weakvaluedictr)set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fields__pydantic_computed_fields__set_deprecated_descriptors__pydantic_init_subclass__popclear)!mcsr`rarcrergrirkbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrscls BaseModel_mrormissing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrr instance_slotrrr{rrMs! @@@rNrzModelMetaclass.__new__Qs 6 R NDGD[D[\aDbDb A j*A*4UIvNNN(6(BIn %!2>7EU"" " K%< K+>y%+P+P(+7@@@@@@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`  &+9*>s*C*CC '-. 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% E E E$ 29)D)D%c5111 "'$8     00&)&A&Q&W&W&Y&Y000C , 's + + + 7E#sOO 6 @ @ @ @ @J"i    ! MM+R 0 0 6 6 8 8 8"577?3%MMfMM MrOitemcp|jd}|r ||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rv)__dict__rCAttributeError)rKrrs rN __getattr__zModelMetaclass.__getattr__sE!%!2!23K!L!L ! 0d.@&@&@)$// && &rOrdict[str, object]ctSr~)r:)rrrks rN __prepare__zModelMetaclass.__prepare__ s"$$$rOinstancecft|do t|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrrI__instancecheck__)rKrrMs rNrz ModelMetaclass.__instancecheck__s. x!9::buww?X?XYa?b?bbrO6tuple[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 issubclassupdaterkeysrurv)rar8 field_namesrrbases rNrz"ModelMetaclass._collect_bases_datas,.. # "uu :< G GD$ ** Gt9/D/D""741F#K#K#P#P#R#RSSS!!$"5666"))$*EFFFJ(:::rOEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cHtjdtd|jS)Nrrrx)rErFr model_fieldsrKs rN __fields__zModelMetaclass.__fields__$s1  S %      rOc$t|diS)zGet metadata about the fields defined on the model. Returns: A mapping of field names to [`FieldInfo`][pydantic.fields.FieldInfo] objects. rrrs rNrzModelMetaclass.model_fields.st2B777rOdict[str, ComputedFieldInfo]c$t|diS)zGet metadata about the computed fields defined on the model. Returns: A mapping of computed field names to [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects. rrrs rNmodel_computed_fieldsz$ModelMetaclass.model_computed_fields7st;R@@@rO list[str]ctt}d|vr|d|S)Nr)listrI__dir__remove)rK attributesrMs rNrzModelMetaclass.__dir__@sC%''//++,, : % %   l + + +rO)NTN)r`r<rarbrcrdrerfrgrhrirjrkrr?rl)rr<r?r)rrrkrr?r)rrr?rh)rarbr?r)r?r)r?r)r?r)rPrQrRrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrrrTrUs@rNr_r_OsIM48+/mNmNmNmNmNmNmN^  ' ' ' ' '%%%[%cccccc ; ; ;\ ;ZWbfggg!!!hgX!888X8AAAXArOr_rKr8ror@ct|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)rrvr get_defaultrobject_setattr)rKropydantic_privater private_attrdefaults rNrqrqGst+T22:"&"="C"C"E"E 1 1 D,"..00G///)0 &t35EFFFFF ;:rOrcrdrarbCallable[..., 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.rtN)r&rrt)rcrar8rts rNrrYsPI%%*++(**I.u6GHHOi77787rOrbase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c hddlmm}t}|t z}i}|di}d|vsd|vrt dt} t| D] \} } | dks| dkrt| tr6| j |dkr%d |vr!| j |d r^t| |s| jj d kr| | t| rY| d rt#d | d t%| rt#dd| 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~)rD)rr=r5s rNrz$inspect_namespace..s3$\$\1JqJZ<[<[$\Q$\$\$\$\$\$\rO)#fieldsr5r7r'default_ignored_typesrCrrrrrDrlrQrR startswithrMadd NameErrorr!lstripr"r/r rrr<sys _getframer-r, f_globalsf_localsr.rnext)rcrr r r7r4all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarr5s @rNrresb476666666(**I%(=(?(??68mm$5r::O_$$ i(?(?oppp!eeM  1 122;;% ~ % %5I)I)I  ud # #8  Il$;;;)++"--i.GHH,  0 1 10 U_5OS^5^5^   h ' ' '  / 0 0- ""4(( PBJPPP%X.. [/2X~[[MU[[[,1 x ((## y ) ) 2Eh2O2O %__S11?ZNJ,JJrrr0)rrabase_hash_func new_hash_funcs rNrrsa-eZ@@N"3''M$000GNJX\4]4]anaw4w4w% 5x4wrOcr|jr%tj|jnddfd }|S)NcdS)NrrZ)rs rNz make_hash_func..slmrOrKrr?intc t|jS#t$r-tt|jcYSwxYwr~)hashrKeyErrorr2)rKgetters rN hash_funcz!make_hash_func..hash_funcsm At}--.. . A A A / >>??@@ @ @ @  As 4AA)rKrr?r7)roperator itemgetterr)rr<r;s @rNr1r1s\EHE\ mX #"9">">"@"@ A AbmbmFAAAAAA rOrrrNsResolver | Nonec t|}t|||||\}}||_|j||D]C}|j|d}|$|jturt|||jDdS)a<Collect and set `cls.__pydantic_fields__` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. bases: Parents of the class, generally `cls.__bases__`. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting model annotations. ) typevars_mapN) r%r rrurrvrrrsetattr) rrarrrArrr;r)s rNrr s*#..L-c5.+dpqqqFJ$Cj)))  + +*..q$77  6G!G!G CEM * * * + +rOrr`r<rrhrrjc (|jrt||dSt|}t|||}t t |jd|d} |||} n5#t$r(} |rt||d| j dYd} ~ dSd} ~ wwxYw| |j } | | } n!#|j $rt||YdSwxYw| |_t| ||p|j|j|rdnd | |j|_t)| | |_d |_t/d t t0|j|j|j|j |_d S) a&Finish 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. ns_resolver: The namespace resolver instance to use during schema building. 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_moderBN)title create_modelr8T __signature__)rWrpopulate_by_nameextra) defer_buildr(r%r#r*rgenerate_schema__get_pydantic_core_schema__rr core_configrP clean_schemaCollectedInvalid__pydantic_core_schema__rrQrRplugin_settingsrr__pydantic_serializer__rr1r+rrrJrKrI) rr`rrrrrA gen_schemahandlerschemaerOs rNrr+s:!X&&&u)#..LJ + *NNNG 11#w?? &   X}16}}}555uuuuu  !,,3<,@@K((00  &X&&&uu $*C !8 -s~ ->;&""C#36;"G"GC $C + '*+< &      C 4s*!A88 B*B%%B* CC=<C=c|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 % % %&&rOcBeZdZUdZded<ddd ZddZdddZddZdS)r\aWRead-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_nameNr`r]property | Noner?r@c"||_||_dSr~)r`r])rKr`r]s rNrz#_DeprecatedFieldDescriptor.__init__s 0rOrrwrc||_dSr~)rd)rKrrs rNrz'_DeprecatedFieldDescriptor.__set_name__s rOrBaseModel | Noneobj_typetype[BaseModel] | Nonerc&|6|j|jd|St|jt j|jtjd|j|j||S|j |jS)Nrrx) r]__get__rrdrErFr`builtinsDeprecationWarningr)rKrris rNrlz"_DeprecatedFieldDescriptor.__get__s ;$0,44T8DDD 11 1 dh ;JJJJ  ,(00h?? ?|DO,,rOr)r c*t|jr~)rrd)rKrr)s rN__set__z"_DeprecatedFieldDescriptor.__set__sT_---rOr~)r`r<r]rer?r@)rrwrr<r?r@)rrhrirjr?r)rrr)rr?r ) rPrQrRrSrrrrlrprZrOrNr\r\sOOO11111 - - - - -......rOr\c*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`). rrcN| d|_dStj||_dSr~)_wrweakrefref)rKrs rNrz_PydanticWeakRef.__init__s) ;DHHH{3''DHHHrOr?c<|jdS|Sr~)rtrs rN__call__z_PydanticWeakRef.__call__s 8 488:: rO4tuple[Callable, tuple[weakref.ReferenceType | None]]c&t|ffSr~)rrrs rN __reduce__z_PydanticWeakRef.__reduce__s$$&&**rON)rr)r?r)r?ry)rPrQrRrSrrxr{rZrOrNrrrrsZ (((( ++++++rOrrddict[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)rrrr)r|resultr;r=proxys rNrrsv 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)rrDrr)r|rr;r=s rNrrsiyt F 1 a) * * A}q F1II MrO)maxsizecddlm}tttt t |tg}tj dkr| tjt|S)Nr)r3) ) rr3rrrrrrr  version_infoappendrr)r3rs rNrrsg****** M 7""V1222   rO)rWrXr?rr)rcrdrarbr?r) rcrdrrbr r r r r?r )rrwrarbr?r@)rrwr?r) rrwrarbrrrr?r?r@)rrwr`r<rrrrhrr?rrjr?rh)rrwr?r@)r|r}r?r})r?rb)jrS __future__r _annotationsrmr=r rrEruabcrrrrtypesrrr r r r r pydantic_corerrtyping_extensionsrrrrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsr r!r"_generate_schemar# _genericsr$r% _import_utilsr&r' _mock_val_serr(_namespace_utilsr)_schema_generation_sharedr* _signaturer+ _typing_extrar,r-r.r/r0_utilsr1r2rrr3r4r5r6PydanticModelFieldr7PydanticModelPrivateAttrmainr8rnr> __setattr__rrr:r[r_rqrrrr1rrrr\rrrrrrZrOrNrs%((222222 ((((((((BBBBBBBBBBBBBBBB========VVVVVVVVVVVVCCCCCCCC>>>>>>OOOOOOOO""""""ssssssssssssYYYYYYYYYY,,,,,,FFFFFFFFMMMMMMMM******((((((CCCCCC33333398888888  (GGGGGGGGGG444444@@@@@@       3%vxx# ) ) ) ) )$ ) ) )!T=OQikv