o ~j6h@sdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZmZddlmZddlmZmZmZmZmZmZddlmZmZdd lmZmZmZmZm 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.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4ddl5m6Z6m7Z7ddl8m9Z9m:Z:ddl;mm?Z?ddl@mAZAddlBmCZCddlDmEZEmFZFmGZGmHZHddlImJZJmKZKejLrd dlMmNZOd dlMmPZPmQZQd dlMmRZSd dlTmUZUne)ZVeWZOeWZSeWjXZYGdd d eZZ[d!d"dbd'd(Z\ed)eOeSe\fd*Gd+d,d,e Z]dcd1d2Z^ddd8d9Z_ded?d@Z`dfdCdDZadgdEdFZbdhdKdLZcd)dddMdidRdSZddjdTdUZeGdVdWdWZfGdXdYdYZgdkd\d]Zhdkd^d_Zie dld`daZjdS)mz"Private logic for creating models.) annotationsN)ABCMeta)cachepartialwraps) FunctionType)AnyCallableGenericLiteralNoReturncast)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_name)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) 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__u/var/www/html/chefvision.cloud.itp360.com/venv/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__rMrMrKrNr97sr9FinitrULiteral[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 NoInitFieldDrXT)kw_only_defaultfield_specifierscseZdZ   d0d1fdd Zejsd2ddZed3ddZd4fdd Z d5fd!d" Z e d6d$d%Z e ed&dd'd7d)d*Ze d8d+d,Zd9fd.d/ 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#| r@t||durr?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_initxs z7ModelMetaclass.__new__..wrapped_model_post_initmodel_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__Frb parametersrM__parameters__c3s|]}|vVqdSNrM.0x)rvrMrN sz)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)config_wrapper ns_resolvercSi|]\}}||jqSrMinforzr:r<rMrMrN s z*ModelMetaclass.__new__.. raise_errorsrcreate_model_module__hash__)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rIr8rkrr>r?):_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrrlr rG__new__r)__mro__r indexrCrDrgetattr__init____pydantic_custom_init__ro__pydantic_post_init____pydantic_setattr_handlers__rbuild__pydantic_decorators__rbrAall root_modelr}tuplejoinrO TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr1rrBdictunpack_lenient_weakvaluedictr,set_model_fieldscomputed_fields__pydantic_computed_fields__ defer_buildr+complete_model_classfrozenset_default_hash_func__pydantic_init_subclass__popclear)mcsr]r^r`rbrdrfrhbase_field_names class_varsbase_private_attributesrprivate_attributesrncls BaseModel_mror}missing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrr instance_slotrK)rmrvr~rNrPs      $          zModelMetaclass.__new__itemcCs(|jd}|r||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rq)__dict__rAAttributeError)rIrrrMrMrN __getattr__ s  zModelMetaclass.__getattr__rdict[str, object]cOstSrx)r9)rrrhrMrMrN __prepare__szModelMetaclass.__prepare__instancect|do t|S)zsAvoid calling ABC _abc_instancecheck unless we're pretty sure. See #3829 and python/cpython#92810 r)hasattrrG__instancecheck__)rIrrKrMrNrz ModelMetaclass.__instancecheck__subclass type[Any]cr)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 r)rrG__subclasscheck__)rIrrKrMrNrrz ModelMetaclass.__subclasscheck__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)set issubclassupdaterkeysrprq)r^r8 field_namesrrbaserMrMrNr#s   z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cCstjdtddt|diS)Nrrrsr)rCrDrrrIrMrMrN __fields__2s  zModelMetaclass.__fields__cCs0t|dsdStd|j}tdd|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. rFrcss|]}|jVqdSrx) _complete)rz field_inforMrMrNr|Gsz>ModelMetaclass.__pydantic_fields_complete__..)rr rrvalues)rI field_infosrMrMrN__pydantic_fields_complete__<s  z+ModelMetaclass.__pydantic_fields_complete__ list[str]cs$tt}d|vr|d|S)Nr)listrG__dir__remove)rI attributesrKrMrNrIs zModelMetaclass.__dir__)NTN)r]r;r^r_r`rarbrcrdrerfrgrhrr>ri)rr;r>r)rrrhrr>r)rrr>re)rrr>re)r^r_r>r)r>r)r>re)r>r)rOrPrQrtyping TYPE_CHECKINGr classmethodrrr staticmethodrpropertyrrrrrSrMrMrKrNr\Ns(8      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_attrdefaultrMrMrNrlPs 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)r ro)r`r^r8rorMrMrNrbs  rrbase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c sddlmm}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 !t"|rt#|^}}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)r6r7r__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 )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)globalnslocalnsc3s|] }t|r|VqdSrx)rB)rzr<r6rMrNr|sz$inspect_namespace..)%fieldsr6r7r*default_ignored_typesrArrrrrBrirPrQ startswithrLadd NameErrorr#lstripr$r0r rrr;sys _getframer/r. f_globalsf_localsr is_annotatedrrnext)r`rrrr7r5all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarrMrrNrns                     rrrrcCs@t|d}t|}|dtjhvst|dd|jkr||_dSdS)Nr__code__)r make_hash_funcr=rrr%)rr^base_hash_func new_hash_funcrMrMrNrs   rcs0|jr tj|jnddd fdd }|S) NcSrW)NrrM)rrMrMrNrYz make_hash_func..rIrr>intcs6zt|jWStytt|jYSwrx)hashrKeyErrorr3rgetterrMrN hash_funcs  z!make_hash_func..hash_func)rIrr>r*)roperator itemgetterr)rr/rMr-rNr&s r&rrrNsResolver | NonecCsjt|}t||||d\}}||_|j||D]}|j|d}|dur2|jtur2t |||jqdS)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"rrprrqrrrsetattr)rrrr3rrr:rrMrMrNrs  rrrrerrgc Cs$t|}t|||}z||}Wn ty1}z|rt|d|jdWYd}~dSd}~ww|j|jd} z||}Wnt yNt|YdSwdd|j j D|_ t|||_t|||pi|j|j|rodnd| |j|_t|| |_d |_td tt|j|j|j|jd |_d S) 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. 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`. r@NF)titlecSrrMrrrMrMrNrfsz(complete_model_class.. create_modelr8T __signature__)rUrvalidate_by_nameextra) r(r%generate_schemarr+r core_configrO clean_schemar&rrrrset_deprecated_descriptors__pydantic_core_schema__rrPrQplugin_settings__pydantic_validator__r__pydantic_serializer__rr2rr-rrr8r9r7) rrrrrr3 gen_schemaschemaer;rMrMrNr2s^    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_DeprecatedFieldDescriptorrr4rrr!wrapped_property)rfieldrmsgdesccomputed_field_inforMrMrNr=s     r=c@sFeZdZUdZded<ddd d ZdddZddddZd ddZdS)!rGaWRead-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_nameNrJrHproperty | Noner>r?cCs||_||_dSrx)rJrH)rIrJrHrMrMrNrs z#_DeprecatedFieldDescriptor.__init__rrrrcCs ||_dSrx)rM)rIrrrMrMrNr z'_DeprecatedFieldDescriptor.__set_name__rBaseModel | Noneobj_typetype[BaseModel] | NonercCsb|dur|jdur|jd|St|jtj|jtjdd|jdur+|j||S|j |jS)Nrrs) rH__get__rrMrCrDrJbuiltinsDeprecationWarningr)rIrrQrMrMrNrSs    z"_DeprecatedFieldDescriptor.__get__rr cCs t|jrx)rrM)rIrrrMrMrN__set__rOz"_DeprecatedFieldDescriptor.__set__rx)rJr;rHrNr>r?)rrrrr;r>r?)rrPrQrRr>r)rrrrr>r ) rOrPrQrRrrrrSrVrMrMrMrNrGs    rGc@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)rIrrMrMrNrs z_PydanticWeakRef.__init__r>cCs|jdurdS|Srx)rXrrMrMrN__call__s z_PydanticWeakRef.__call__4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrx)rWrrMrMrN __reduce__s z_PydanticWeakRef.__reduce__N)rr)r>r)r>r\)rOrPrQrRrr[r]rMrMrMrNrWs   rWddict[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)rrWr)r^resultr:r<proxyrMrMrNrs   rcCsP|durdSi}|D]\}}t|tr!|}|dur |||<q |||<q |S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrBrW)r^r`r:r<rMrMrNrs  rcCs<ddlm}ttttt|tg}tj dkr| t jt |S)Nr)ComputedFieldInfo) ) rrbrrrrrrr version_infoappendrr)rbrrMrMrNrs  r)rUrVr>rr)r`rar^r_r>r) r`rarr_rrrrr>r)rrrr^r_r>r?)rrrr>r)rrrrrrr2r>r?) rrrrrrrerr2rrgr>re)rrrr>r?)r^r_r>r_)r>r_)krR __future__r _annotationsrTr0rrrCrYabcrrrrrtypesrrr r r r r pydantic_corerrtyping_extensionsrrrrrtyping_inspectionrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrr r!_fieldsr"r#r$_generate_schemar%r& _genericsr'r( _import_utilsr)r* _mock_val_serr+_namespace_utilsr, _signaturer- _typing_extrar.r/r0r1_utilsr2r3rrr4PydanticModelFieldr5r6r7PydanticModelPrivateAttrmainr8rUr= __setattr__rrr9rXr\rlrrrr&rrr=rGrWrrrrMrMrMrNs~                 # V% #