o zsgǏ@sdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddlmZddlmZmZmZmZmZmZmZddlmZmZdd lmZmZmZmZd d l m!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/m0Z0m1Z1ddl2m3Z3ddl4m5Z5m6Z6ddl7m8Z8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAddlBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJejKrd dlLmMZMmNZNmOZOd dlLmPZQd dlLmRZSd dlTmUZUne&ZVeWZQeWZSeWjXZYGdd d eZZ[d!d"ded'd(Z\ed)eQeSe\fd*Gd+d,d,e Z]dfd1d2Z^dgd8d9Z_dhd?d@Z`didCdDZadjdEdFZbdkdKdLZcd)dddMdldTdUZddmdVdWZeGdXdYdYZfGdZd[d[Zgdnd^d_Zhdnd`daZie ddbdodcddZjdS)pz"Private logic for creating models.) annotationsN)ABCMeta) lru_cachepartial) FunctionType)AnyCallableGenericLiteralNoReturnTypeVarcast)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) BaseModelcs"eZdZdZd fdd ZZS) _ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. kstrvobjectreturnNonecsL||d}|r||urt|trtd|d|jjdt||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarndecorator_infodecorator_reprsuper __setitem__)selfr:r<existing __class__b/var/www/html/minecraft/env/lib/python3.10/site-packages/pydantic/_internal/_model_construction.pyrH=s z_ModelNamespaceDict.__setitem__)r:r;r<r=r>r?)__name__ __module__ __qualname____doc__rH __classcell__rMrMrKrNr98sr9FinitrULiteral[False]r>rcCdS)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. NrMrTrMrMrN NoInitFieldErXT)kw_only_defaultfield_specifierscseZdZ   d2d3fdd Zd4fdd Zejsd5ddZed6ddZ d7fd d! Z e d8d#d$Z e ed%dd&d9d(d)Ze d9d*d+Ze d:d-d.Zd;fd0d1 ZZS)<ModelMetaclassNTcls_namer;basestuple[type[Any], ...] namespacedict[str, Any]__pydantic_generic_metadata__PydanticGenericMetadata | None#__pydantic_reset_parent_namespace__bool_create_model_module str | Nonekwargsrr>typec s|r||\}} } t|||} | j|d<t|| j| |} | s#| rr?cst||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rIrk)original_model_post_initrMrNwrapped_model_post_initys z7ModelMetaclass.__new__..wrapped_model_post_initmodel_post_init__class_vars____private_attributes__rbtype[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__F parametersrM__parameters__c3s|]}|vVqdSNrM.0x)rvrMrN z)ModelMetaclass.__new__..)RootModelRootTypec3s|] }|vr|VqdSrxrMry)parent_parametersrMrNr|sz, cSg|]}|jqSrMrOryrMrMrN z*ModelMetaclass.__new__..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 ]): ...`.cSsg|]}t|qSrM)r;ryrMrMrNrsztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSrrMrryrMrMrNrrz- Note: `typing.Generic` must go last: `class (z): ...`))originargsrv__pydantic_parent_namespace__)parent_namespace__hash__ raise_errors ns_resolvercreate_model_modulecSsi|]\}}||jqSrM)info)rzr:r<rMrMrN s z*ModelMetaclass.__new__..)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rIr8rkrr>r?)7_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrlr rG__new__r&__mro__r indexrCrDrgetattr__init____pydantic_custom_init__ro__pydantic_post_init__rbuild__pydantic_decorators__rbrAall root_modelr~tuplejoinrO TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr0rrBdictunpack_lenient_weakvaluedictr)set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fields__pydantic_computed_fields__set_deprecated_descriptors__pydantic_init_subclass__popclear)mcsr]r^r`rbrdrfrhbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrncls BaseModel_mror~missing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrr instance_slotrK)rmrvrrNrQs      $         zModelMetaclass.__new__list[type[Any]]cs@t}|jtfkr |S|jd}|s|Sd}|d|d}}|s&|S|jd}tt|||h}|g}|ddD]_} t | did} t | didd} | |vrXq>| |vr| rt |  ksjJ|t fdd | D} | | } | | || p| | durq>n|| p| | |d ur| | q>|S) NrbzUnexpected error occurred when generating MRO of generic subclass. Please report this issue on GitHub: https://github.com/pydantic/pydantic/issues.rrrvrrMc3s|]}|VqdSrxrM)rzparam param_dictrMrNr|$r}z%ModelMetaclass.mro..)rGr __bases__r=__dict__rArbrziprsetkeysrappendadd)r original_mrogeneric_metadataassert_err_msgrr target_paramsindexed_originsnew_mrobase base_origin base_params new_base_argsnew_baserKrrNrsF        zModelMetaclass.mroitemcCs(|jd}|r||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rq)rrAAttributeError)rIrrrMrMrN __getattr__;s  zModelMetaclass.__getattr__rdict[str, object]cOstSrx)r9)rrrhrMrMrN __prepare__BszModelMetaclass.__prepare__instancecst|do t|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrrG__instancecheck__)rIrrKrMrNrFsz ModelMetaclass.__instancecheck__6tuple[set[str], set[str], dict[str, ModelPrivateAttr]]cCsjt}t}t}i}|D]"}t||r/||ur/|t|di||j||jq |||fS)N__pydantic_fields__)r&r issubclassupdaterrrprq)r^r8 field_namesrrrrMrMrNrMs   z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cCstjdtdd|jS)Nrrrs)rCrDr model_fieldsrIrMrMrN __fields__\s zModelMetaclass.__fields__cC t|diS)zGet metadata about the fields defined on the model. Returns: A mapping of field names to [`FieldInfo`][pydantic.fields.FieldInfo] objects. rrrrMrMrNrf zModelMetaclass.model_fieldsdict[str, ComputedFieldInfo]cCr)zGet metadata about the computed fields defined on the model. Returns: A mapping of computed field names to [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects. rrrrMrMrNmodel_computed_fieldsorz$ModelMetaclass.model_computed_fields list[str]cs$tt}d|vr|d|S)Nr)listrG__dir__remove)rI attributesrKrMrNrxs zModelMetaclass.__dir__)NTN)r]r;r^r_r`rarbrcrdrerfrgrhrr>ri)r>r)rr;r>r)rrrhrr>r)rrr>re)r^r_r>r)r>r)r>r)r>r)rOrPrQrrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrrrSrMrMrKrNr\Os,26      r\rIr8rkr?cCsTt|dddur(i}|jD]\}}|}|tur|||<qt|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)rrqr get_defaultrobject_setattr)rIrkpydantic_privater private_attrdefaultrMrMrNrls rlr`rar^r_Callable[..., Any] | NonecCs2d|vr|dSt}t|d}||jur|SdS)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.roN)r&rro)r`r^r8rorMrMrNrs  rrbase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c s ddlmm}t}|t}i}|di}d|vs d|vr$tdt} t| D]\} } | dks9| dkr:q-t | t rS| j |dkrSd |vrS| j |d rSq-t | |s^| jj d krd| | q-t | r| d rvtd | d t| rtdd| d| d | || <|| =q-t | |rt| s| dpd} td| d| d | d rq-t| r| |vst|| st|| d|| <|| =q-| |vrq-| |vr| |vrtd| dddt | |rtd| dddtd| d| d| dddq-| D]{\} }t| r| |vr| | vrt|s||vrt|ddd krt |tr[td}|dur[ztt|dd d!|j|jd"}Wn ttfyZYnwt |r}t!|^}}t"fd#d$|Dd}|dur}||| <q||| <q|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)r5r7r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rjrrPrQ functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rzJPrivate 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 )r zField 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)globalnslocalnsc3s|] }t|r|VqdSrx)rB)rzr<r5rMrNr|sz$inspect_namespace..)#fieldsr5r7r'default_ignored_typesrArrrrrBrirPrQ startswithrLr NameErrorr!lstripr"r/r rrr;sys _getframer-r, f_globalsf_localsr.rnext)r`rr rr7r4all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatar rMrrNrs                      rrrrcCs@t|d}t|}|dtjhvst|dd|jkr||_dSdS)Nr__code__)rmake_hash_funcr=rrr0)rr^base_hash_func new_hash_funcrMrMrNr%s   rcs0|jr tj|jnddd fdd }|S) NcSrW)NrrM)rrMrMrN3rYz make_hash_func..rIrr>intcs6zt|jWStytt|jYSwrx)hashrKeyErrorr2rgetterrMrN hash_func5s  z!make_hash_func..hash_func)rIrr>r5)roperator itemgetterr)rr:rMr8rNr12s r1rrrNsResolver | Nonec Cslt|}t|||||d\}}||_|j||D]}|j|d}|dur3|jtur3t |||jqdS)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 rrprrqrr rsetattr) rr^rrr>rrr:r*rMrMrNrBs rrr]r;rrerrgc Cs8|jr t||dSt|}t|||}tt|jdd|dd}z|||} Wn!tyI} z|r3t||d| j dWYd} ~ dSd} ~ ww|j |j d} z| | } Wn|j yht||YdSw| |_t| ||ps|j|j|rydnd | |j|_t| | |_d |_td tt|j|j|j|jd |_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_moder@N)title create_modelr8T __signature__)rUrpopulate_by_nameextra) defer_buildr(r%r#r*rgenerate_schema__get_pydantic_core_schema__rr core_configrO clean_schemaCollectedInvalid__pydantic_core_schema__rrPrQplugin_settingsrr__pydantic_serializer__rr1r+rrrFrGrE) rr]rrrrr> gen_schemahandlerschemaerKrMrMrNrcsj      rcCs|jD]\}}|j}dur t|}|||t|||q|jD]%\}}|j}durKtt|j dsKt||j }|||t|||q&dS)z8Set data descriptors on the class for deprecated fields.N__deprecated__) rrdeprecation_message_DeprecatedFieldDescriptorrr?rrrwrapped_property)rfield field_infomsgdesccomputed_field_inforMrMrNrs     rc@sFeZdZUdZded<ddd d ZdddZddddZd ddZdS)!rWaWRead-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[rXproperty | Noner>r?cCs||_||_dSrx)r[rX)rIr[rXrMrMrNrs z#_DeprecatedFieldDescriptor.__init__rrrrcCs ||_dSrx)r^)rIrrrMrMrNr z'_DeprecatedFieldDescriptor.__set_name__rBaseModel | Noneobj_typetype[BaseModel] | NonercCsb|dur|jdur|jd|St|jtj|jtjdd|jdur+|j||S|j |jS)Nrrs) rX__get__rr^rCrDr[builtinsDeprecationWarningr)rIrrbrMrMrNrds    z"_DeprecatedFieldDescriptor.__get__r*r cCs t|jrx)rr^)rIrr*rMrMrN__set__r`z"_DeprecatedFieldDescriptor.__set__rx)r[r;rXr_r>r?)rrrrr;r>r?)rrarbrcr>r)rrr*rr>r ) rOrPrQrRrrrrdrgrMrMrMrNrWs    rWc@s.eZdZdZd ddZdddZdd d Zd 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`). rrcCs"|dur d|_dSt||_dSrx)_wrweakrefref)rIrrMrMrNr s z_PydanticWeakRef.__init__r>cCs|jdurdS|Srx)rirrMrMrN__call__s z_PydanticWeakRef.__call__4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrx)rhrrMrMrN __reduce__s z_PydanticWeakRef.__reduce__N)rr)r>r)r>rm)rOrPrQrRrrlrnrMrMrMrNrhs   rhddict[str, Any] | Nonec CsR|durdSi}|D]\}}zt|}Wn ty!|}Ynw|||<q |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)rrhr)roresultr:r<proxyrMrMrNrs   rcCsP|durdSi}|D]\}}t|tr!|}|dur |||<q |||<q |S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrBrh)rorqr:r<rMrMrNr/s  r)maxsizecCs<ddlm}ttttt|tg}tj dkr| t jt |S)Nr)r3) ) rr3rrrrrrr! version_inforrr)r3rrMrMrNr?s  r)rUrVr>rr)r`rar^r_r>r ) r`rarr_r rrrr>r)rrrr^r_r>r?)rrrr>r) rrrr^r_rrrr=r>r?)rrrr]r;rrrrerr=rrgr>re)rrrr>r?)rorpr>rp)r>r_)krR __future__r _annotationsrer;r!rrCrjabcrrrrtypesrrrr 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_utilsr1r2rrr3r4r5r6PydanticModelFieldr7PydanticModelPrivateAttrmainr8rfr= __setattr__rrr9rXr\rlrrrr1rrrrWrhrrrrMrMrMrNs~   $           1   & ]% #