o @jq@sdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z mZddlmZddlmZmZmZmZmZddlZddlmZmZdd lmZmZd d lmZmZd d lm Z d d lm!Z!m"Z"ddl#m$Z$ddl%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>m?Z?m@Z@mAZAmBZBddlCmDZDmEZEddlFmGZGejHrd dlImJZKd dlImLZLmMZMd dlImNZOd dlPmQZQne"ZReSZKeSZOeSjTZUGdd d eVZWd!d"ddd'd(ZXed)eKeOeXfd*Gd+d,d,e ZYded1d2ZZdfd8d9Z[dgd?d@Z\dhdCdDZ]didEdFZ^djdJdKZ_d)ddLdkdTdUZ`dldVdWZaGdXdYdYZbGdZd[d[Zcdmd]d^Zddmd_d`Zee ddadndbdcZfdS)oz"Private logic for creating models.) annotationsN)ABCMeta) lru_cachepartial) FunctionType)AnyCallableGenericLiteralNoReturn)PydanticUndefinedSchemaSerializer)dataclass_transform deprecated)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)CallbackGetCoreSchemaHandler)generate_pydantic_signature)_make_forward_refeval_type_backport is_annotated is_classvarmerge_cls_and_parent_nsparent_frame_namespace)ClassAttributeSafeGetItemProxy)ValidateCallWrapper)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__)selfr6r8existing __class__u/var/www/www-root/data/www/ai-bot.pdev.uz/venv/lib/python3.10/site-packages/pydantic/_internal/_model_construction.pyrD?s z_ModelNamespaceDict.__setitem__)r6r7r8r9r:r;)__name__ __module__ __qualname____doc__rD __classcell__rIrIrGrJr5:sr5FinitrQLiteral[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. NrIrPrIrIrJ NoInitFieldGrTT)kw_only_defaultfield_specifierscseZdZ   d*d+fdd Zejsd,ddZed-ddZd.fdd Z e d/d d!Z e e d"dd#d0d%d&Zd1fd(d) ZZS)2ModelMetaclassNTcls_namer7basestuple[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.wrapped_model_post_initmodel_post_init__class_vars____private_attributes__zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly.r stacklevel__pydantic_base_init__Fr^ parametersrI__parameters__c3s|]}|vVqdSNrI.0x)rqrIrJ sz)ModelMetaclass.__new__..)RootModelRootTypec3s|] }|vr|VqdSrsrIrt)parent_parametersrIrJrwsz, cSg|]}|jqSrIrKrtrIrIrJ 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|qSrI)r7rtrIrIrJr|sztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSrzrIr{rtrIrIrJr|r}z- Note: `typing.Generic` must go last: `class (z): ...`))originargsrq__pydantic_parent_namespace____hash__) raise_errorstypes_namespacecreate_model_modulecSsi|]\}}||jqSrI)info)rur6r8rIrIrJ sz*ModelMetaclass.__new__..)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rEr4rgrr:r;)6_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrhrC__new__r"__mro__r indexr?r@rgetattr__init____pydantic_custom_init__rk__pydantic_post_init__rbuild__pydantic_decorators__r^r=all root_modelrxtuplejoinrK TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr,rr>dictunpack_lenient_weakvaluedictr+set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fieldsmodel_computed_fieldsset_deprecated_descriptors__pydantic_init_subclass__popclear)mcsrYrZr\r^r`rbrdbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrjclsr4mrorxmissing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjparent_namespacer instance_slotrG)rirqryrJrSs     $         zModelMetaclass.__new__itemcCs(|jd}|r||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rm)__dict__r=AttributeError)rErrrIrIrJ __getattr__s  zModelMetaclass.__getattr__rdict[str, object]cOstSrs)r5)rrrdrIrIrJ __prepare__szModelMetaclass.__prepare__instancecst|do t|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrrC__instancecheck__)rErrGrIrJr sz ModelMetaclass.__instancecheck__6tuple[set[str], set[str], dict[str, ModelPrivateAttr]]cCsjt}t}t}i}|D]"}t||r/||ur/|t|di||j||jq |||fS)N model_fields)r"set issubclassupdaterkeysrlrm)rZr4 field_namesrrbaserIrIrJrs   z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cCstdt|jS)Nr)r?r@rrrErIrIrJ __fields__"szModelMetaclass.__fields__ list[str]cs$tt}d|vr|d|S)Nr)listrC__dir__remove)rE attributesrGrIrJr*s zModelMetaclass.__dir__)NTN)rYr7rZr[r\r]r^r_r`rarbrcrdrr:re)rr7r:r)rrrdrr:r)rrr:ra)rZr[r:r)r:r)r:r)rKrLrMrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrOrIrIrGrJrXQs",    rXrEr4rgr;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)rrmr get_defaultr object_setattr)rErgpydantic_privater private_attrdefaultrIrIrJrh1s rhr\r]rZr[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.rkN)r"rrk)r\rZr4rkrIrIrJrCs  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|| s|| d|| <|| =q-| |vrq-| |vr| |vrtd| dddt | |rtd| dddtd| d| d| dddq-| D]|\} }t| r| |vr| | vrt|s||vrt|ddd krt |trWtd}|durWztt|dd d!|j|jd"}Wn ttfyVYnwt|rzt !|^}}t"fd#d$|Dd}|durz||| <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)r2r3r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rfrrLrM 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|VqdSrs)r>)rur8r2rIrJrwsz$inspect_namespace..)#fieldsr2r3r#default_ignored_typesr=rrrrr>rerLrM startswithrHadd NameErrorrlstriprr*rrr7sys _getframer(r' f_globalsf_localsr)typing_extensionsget_argsnext)r\rrrr3r1all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarrIrrJrOs                    rrtype[BaseModel]cCs@t|d}t|}|dtjhvst|dd|jkr||_dSdS)Nr__code__)rmake_hash_funcr9rrr)rrZbase_hash_func new_hash_funcrIrIrJrs   rcs0|jr tj|jnddd fdd }|S) NcSrS)NrrI)rrIrIrJrUz make_hash_func..rErr:intcs6zt|jWStytt|jYSwrs)hashrKeyErrorr.rgetterrIrJ hash_funcs  z!make_hash_func..hash_func)rErr:r)roperator itemgetterr)rrrIrrJrs rrrrc Cslt|}t|||||d\}}||_|j||D]}|j|d}|dur3|jtur3t |||jqdS)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!rrrlrrmrrr setattr) rrZrrr rrr6r rIrIrJrs  r)rrrYr7rradict[str, Any] | Nonerrcc Cs6t|}t|||}tt|jdd|dd}|jr%d|jvr%t||dSz|||} Wn!t yN} z|r8t||d| j dWYd} ~ dSd} ~ ww| |} z| | } Wn|j ykt||YdSw| |_t| ||pv|j|j|r|dnd | |j|_t| | |_d |_td t|j|j|d |_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. 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_modemodelr<N create_modelr4T __signature__)rQrr)r!rr%rgenerate_schema defer_buildexperimental_defer_build_moder$__get_pydantic_core_schema__rr core_config clean_schemaCollectedInvalid__pydantic_core_schema__rrLrMplugin_settingsrr __pydantic_serializer__rr-r&rrr() rrYrrrrr  gen_schemahandlerschemaer-rIrIrJrs^      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_inforIrIrJrgs     rc@sFeZdZUdZded<ddd d ZdddZddddZd ddZdS)!r9aMData 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. r7 field_nameNr=r:property | Noner:r;cCs||_||_dSrs)r=r:)rEr=r:rIrIrJrs z#_DeprecatedFieldDescriptor.__init__rrrcCs ||_dSrs)r@)rErrrIrIrJr z'_DeprecatedFieldDescriptor.__set_name__rBaseModel | Noneobj_typetype[BaseModel] | NonercCsJ|dur t|jtj|jtjdd|jdur|j||S|j |jS)Nrrn) rr@r?r@r=builtinsDeprecationWarningr:__get__r)rErrDrIrIrJrHs    z"_DeprecatedFieldDescriptor.__get__r r cCs t|jrs)rr@)rErr rIrIrJ__set__rBz"_DeprecatedFieldDescriptor.__set__rs)r=r7r:rAr:r;)rrrr7r:r;)rrCrDrEr:r)rrr rr:r ) rKrLrMrNrrrrHrIrIrIrIrJr9zs     r9c@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||_dSrs)_wrweakrefref)rErrIrIrJrs z_PydanticWeakRef.__init__r:cCs|jdurdS|Srs)rKrrIrIrJ__call__s z_PydanticWeakRef.__call__4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrs)rJrrIrIrJ __reduce__s z_PydanticWeakRef.__reduce__N)rr)r:r)r:rO)rKrLrMrNrrNrPrIrIrIrJrJs   rJdc 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)rrJr)rQresultr6r8proxyrIrIrJrs   rcCsP|durdSi}|D]\}}t|tr!|}|dur |||<q |||<q |S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr>rJ)rQrRr6r8rIrIrJrs  r)maxsizecCsddlm}ttttt|tfS)NrComputedFieldInfo)rrVrrrrrr/rUrIrIrJrs r)rQrRr:rr)r\r]rZr[r:r) r\r]rr[rrrrr:r)rrrZr[r:r;)rrr:r) rrrZr[rrrr]r:r;)rrrYr7rrrrarr"rrcr:ra)rrr:r;)rQr"r:r")r:r[)grN __future__r _annotationsrFrrrr?rLabcrrrrtypesrrrr r r r pydantic_corer r rrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsrrr_generate_schemar _genericsr r! _import_utilsr"r# _mock_val_serr$_schema_generation_sharedr% _signaturer& _typing_extrar'r(r)r*r+r,_utilsr-r._validate_callr/rrr0PydanticModelFieldr1r2r3PydanticModelPrivateAttrmainr4rGr9 __setattr__rrr5rTrXrhrrrrrrrr9rJrrrrIrIrIrJs|               `   # U# #