o g@sdZddlmZddlZddlZddlZddlZddlZddl 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 d eYZZd!d"ded'd(Z[ed)ePeRe[fd*Gd+d,d,e Z\dfd1d2Z]dgd8d9Z^dhd?d@Z_didCdDZ`djdEdFZadkdKdLZbd)dddMdldTdUZcdmdVdWZdGdXdYdYZeGdZd[d[Zfdnd^d_Zgdnd`daZhe ddbdodcddZidS)pz"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) 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__)selfr9r;existing __class__]/var/www/visachat/venv/lib/python3.10/site-packages/pydantic/_internal/_model_construction.pyrG=s z_ModelNamespaceDict.__setitem__)r9r:r;r<r=r>)__name__ __module__ __qualname____doc__rG __classcell__rLrLrJrMr88sr8FinitrTLiteral[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. NrLrSrLrLrM NoInitFieldErWT)kw_only_defaultfield_specifierscseZdZ   d/d0fdd Zejsd1ddZed2ddZd3fdd Z e d4d d!Z e e d"dd#d5d%d&Ze d5d'd(Ze d6d*d+Zd7fd-d. ZZS)8ModelMetaclassNTcls_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#| rcst||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rHrj)original_model_post_initrLrMwrapped_model_post_initys 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__Fra parametersrL__parameters__c3s|]}|vVqdSNrL.0x)rurLrM sz)ModelMetaclass.__new__..)RootModelRootTypec3s|] }|vr|VqdSrwrLrx)parent_parametersrLrMr{sz, cSg|]}|jqSrLrNrxrLrLrM 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|qSrL)r:rxrLrLrMrsztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSr~rLrrxrLrLrMrrz- Note: `typing.Generic` must go last: `class (z): ...`))originargsru__pydantic_parent_namespace__)parent_namespace__hash__ raise_errors ns_resolvercreate_model_modulecSsi|]\}}||jqSrL)info)ryr9r;rLrLrM s z*ModelMetaclass.__new__..)__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__rHr7rjrr=r>)7_collect_bases_datar for_model config_dictinspect_namespace ignored_typesget_model_post_initrkr rF__new__r%__mro__r indexrBrCrgetattr__init____pydantic_custom_init__rn__pydantic_post_init__rbuild__pydantic_decorators__rar@all root_modelr|tuplejoinrN TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr/rrAdictunpack_lenient_weakvaluedictr(set_model_fieldsfrozenset_default_hash_funccomplete_model_classcomputed_fields__pydantic_computed_fields__set_deprecated_descriptors__pydantic_init_subclass__popclear)mcsr\r]r_rarcrergbase_field_names class_varsbase_private_attributesconfig_wrapperprivate_attributesrmcls BaseModel_mror|missing_parametersparameters_str error_messagecombined_parametersgeneric_type_label bases_strnameobjrr instance_slotrJ)rlrur}rMrQs      $         zModelMetaclass.__new__itemcCs(|jd}|r||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.rp)__dict__r@AttributeError)rHrrrLrLrM __getattr__s  zModelMetaclass.__getattr__rdict[str, object]cOstSrw)r8)rrrgrLrLrM __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__)hasattrrF__instancecheck__)rHrrJrLrMrsz 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%set issubclassupdaterkeysrorp)r]r7 field_namesrrbaserLrLrMrs   z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cCstjdtdd|jS)Nrrrr)rBrCr model_fieldsrHrLrLrM __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. rrrrLrLrMr. 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. rrrrLrLrMmodel_computed_fields7rz$ModelMetaclass.model_computed_fields list[str]cs$tt}d|vr|d|S)Nr)listrF__dir__remove)rH attributesrJrLrMr@s zModelMetaclass.__dir__)NTN)r\r:r]r^r_r`rarbrcrdrerfrgrr=rh)rr:r=r)rrrgrr=r)rrr=rd)r]r^r=r)r=r)r=r)r=r)rNrOrPrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrrrRrLrLrJrMr[Os*0      r[rHr7rjr>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)rrpr get_defaultr object_setattr)rHrjpydantic_privater private_attrdefaultrLrLrMrkGs rkr_r`r]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.rnN)r%rrn)r_r]r7rnrLrLrMrYs  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)r4r6r__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rirrOrP 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|VqdSrw)rA)ryr;r4rLrMr{sz$inspect_namespace..)#fieldsr4r6r&default_ignored_typesr@rrrrrArhrOrP startswithrKadd NameErrorr lstripr!r.r rrr:sys _getframer,r+ f_globalsf_localsr-rnext)r_rrrr6r3all_ignored_typesrraw_annotations ignored_namesvar_namevaluesuggested_nameann_nameann_typeframermetadatarrLrrMres                      rrrqcCs@t|d}t|}|dtjhvst|dd|jkr||_dSdS)Nr__code__)rmake_hash_funcr<rrr)rr]base_hash_func new_hash_funcrLrLrMrs   rcs0|jr tj|jnddd fdd }|S) NcSrV)NrrL)rrLrLrMrXz make_hash_func..rHrr=intcs6zt|jWStytt|jYSwrw)hashrKeyErrorr1rgetterrLrM hash_funcs  z!make_hash_func..hash_func)rHrr=r!)roperator itemgetterr)rr&rLr$rMrs rrrrNsResolver | 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$rrrorrprrr setattr) rr]rrr*rrr9rrLrLrMr s rrr\r:rrdrrfc 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_modelr7T __signature__)rTrpopulate_by_nameextra) defer_buildr'r$r"r)rgenerate_schema__get_pydantic_core_schema__rr core_configrN clean_schemaCollectedInvalid__pydantic_core_schema__rrOrPplugin_settingsrr__pydantic_serializer__rr0r*rrr2r3r1) rr\rrrrr* gen_schemahandlerschemaer7rLrLrMr+sj      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_inforLrLrMrs     rc@sFeZdZUdZded<ddd d ZdddZddddZd ddZdS)!rCaWRead-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_nameNrGrDproperty | Noner=r>cCs||_||_dSrw)rGrD)rHrGrDrLrLrMrs z#_DeprecatedFieldDescriptor.__init__rrqrcCs ||_dSrw)rJ)rHrrrLrLrMr z'_DeprecatedFieldDescriptor.__set_name__rBaseModel | Noneobj_typetype[BaseModel] | NonercCsb|dur|jdur|jd|St|jtj|jtjdd|jdur+|j||S|j |jS)Nrrr) rD__get__rrJrBrCrGbuiltinsDeprecationWarningr)rHrrNrLrLrMrPs    z"_DeprecatedFieldDescriptor.__get__rr cCs t|jrw)rrJ)rHrrrLrLrM__set__rLz"_DeprecatedFieldDescriptor.__set__rw)rGr:rDrKr=r>)rrqrr:r=r>)rrMrNrOr=r)rrrrr=r ) rNrOrPrQrrrrPrSrLrLrLrMrCs    rCc@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||_dSrw)_wrweakrefref)rHrrLrLrMrs z_PydanticWeakRef.__init__r=cCs|jdurdS|Srw)rUrrLrLrM__call__s z_PydanticWeakRef.__call__4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrw)rTrrLrLrM __reduce__s z_PydanticWeakRef.__reduce__N)rr)r=r)r=rY)rNrOrPrQrrXrZrLrLrLrMrTs   rTddict[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)rrTr)r[resultr9r;proxyrLrLrMrs   rcCsP|durdSi}|D]\}}t|tr!|}|dur |||<q |||<q |S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrArT)r[r]r9r;rLrLrMrs  r)maxsizecCs<ddlm}ttttt|tg}tj dkr| t jt |S)Nr)r2) ) rr2rrrrrrr  version_infoappendrr)r2rrLrLrMrs  r)rTrUr=rr)r_r`r]r^r=r) r_r`rr^rrrrr=r)rrqr]r^r=r>)rrqr=r) rrqr]r^rrrr)r=r>)rrqr\r:rrrrdrr)rrfr=rd)rrqr=r>)r[r\r=r\)r=r^)jrQ __future__r _annotationsrQr'r rrBrVabcrrrrtypesrrrr r r r pydantic_corer rtyping_extensionsrrrrerrorsrrplugin._schema_validatorrrr_configr _decoratorsrrrr_fieldsrr r!_generate_schemar" _genericsr#r$ _import_utilsr%r& _mock_val_serr'_namespace_utilsr(_schema_generation_sharedr) _signaturer* _typing_extrar+r,r-r.r/_utilsr0r1rrr2r3r4r5PydanticModelFieldr6PydanticModelPrivateAttrmainr7rRr< __setattr__rrr8rWr[rkrrrrrrrrCrTrrrrLrLrLrMs|               x   & ]% #