U EZh @s:dZddlmZddlZddlZddlZddlZddlZddl 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"d#d$d%d&d'Z[ed(ePeRe[fd)Gd*d+d+e Z\d,d$d-d.d/d0Z]d1d2d3d4d5d6Z^d1d2d7d7d8d9d:d;Z_dd?Z`d||k r>t|tr>td|d|jjdt||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarnZdecorator_infoZdecorator_reprsuper __setitem__)selfr<r=existing __class__m/home/aprabhat/apps/x.techxrdev.in/venv/lib/python3.8/site-packages/pydantic/_internal/_model_construction.pyrE=s z_ModelNamespaceDict.__setitem__)__name__ __module__ __qualname____doc__rE __classcell__rJrJrHrKr88sr8FinitzLiteral[False]r)rRr>cCsdS)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. NrJrQrJrJrK NoInitFieldEsrST)kw_only_defaultfield_specifiersc seZdZd*ddddddd d d fd d Zejs@dd dddZed d ddddZd ddfdd Z e dddddZ e e dddddd d!Ze ddd"d#Ze d$dd%d&Zd'dfd(d) ZZS)+ModelMetaclassNTr9tuple[type[Any], ...]dict[str, Any]zPydanticGenericMetadata | Nonebool str | Nonertype)cls_namebases namespace__pydantic_generic_metadata__#__pydantic_reset_parent_namespace___create_model_modulekwargsr>c s|rB||\}} } t|||} | j|d<t|| j| |} | sF| rt||dk rxddddfdd } | |d <nt|d <| |d <| | |d <td t j ||||f|}t }|j }t |kr|t ||krtjtd ddt|jdd |_|j|jkrdnd |_t||_|r0||_ncst||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rFre)original_model_post_initrJrKwrapped_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 stacklevelZ__pydantic_base_init__Fr_ parametersrJ__parameters__c3s|]}|kVqdSNrJ.0x)rorJrK sz)ModelMetaclass.__new__..)RootModelRootTypec3s|]}|kr|VqdSrqrJrr)parent_parametersrJrKrusz, cSsg|] }|jqSrJrLrrrJrJrK sz*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|qSrJ)r9rrrJrJrKrysztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSsg|] }|jqSrJrxrrrJrJrKrysz- Note: `typing.Generic` must go last: `class (z): ...`))originargsro__pydantic_parent_namespace__)parent_namespace__hash__ raise_errors ns_resolvercreate_model_modulecSsi|]\}}||jqSrJ)info)rsr<r=rJrJrK sz*ModelMetaclass.__new__..)Z__pydantic_fields_set____pydantic_extra____pydantic_private____annotations__)7_collect_bases_datarZ for_modelZ config_dictinspect_namespace ignored_typesget_model_post_initrfr rD__new__r%__mro__r indexrBrCrgetattr__init__Z__pydantic_custom_init__riZ__pydantic_post_init__rbuildZ__pydantic_decorators__r_r@allZ root_modelrvtuplejoinrL TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr/rrAdictunpack_lenient_weakvaluedictr(set_model_fieldsfrozenset_default_hash_funccomplete_model_classZcomputed_fields__pydantic_computed_fields__set_deprecated_descriptorsZ__pydantic_init_subclass__popclear)mcsr\r]r^r_r`rarbZbase_field_names class_varsZbase_private_attributesconfig_wrapperprivate_attributesrhclsZ BaseModel_mrorvZmissing_parametersZparameters_str error_messageZcombined_parametersZgeneric_type_labelZ bases_strnameobjrrZ instance_slotrH)rgrorwrKrQs      $           zModelMetaclass.__new__)itemr>cCs,|jd}|r ||kr ||St|dS)zNThis is necessary to keep attribute access working for class attribute access.rkN)__dict__r@AttributeError)rFrrrJrJrK __getattr__s  zModelMetaclass.__getattr__zdict[str, object])r~rbr>cOstSrq)r8)rr~rbrJrJrK __prepare__ szModelMetaclass.__prepare__)instancer>cst|dot|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 __pydantic_validator__)hasattrrD__instancecheck__)rFrrHrJrKrsz ModelMetaclass.__instancecheck__z6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])r]r>cCsjt}t}t}i}|D]D}t||r||k r|t|di||j||jq|||fS)N__pydantic_fields__)r%set issubclassupdaterkeysrjrk)r]r7 field_namesrrbaserJrJrKrs z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categoryzdict[str, FieldInfo]r>cCstjdtdd|jS)Nrrrm)rBrCr model_fieldsrFrJrJrK __fields__$s zModelMetaclass.__fields__cCs t|diS)zGet metadata about the fields defined on the model. Returns: A mapping of field names to [`FieldInfo`][pydantic.fields.FieldInfo] objects. rrrrJrJrKr.szModelMetaclass.model_fieldszdict[str, ComputedFieldInfo]cCs 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. rrrrJrJrKmodel_computed_fields7sz$ModelMetaclass.model_computed_fieldsz list[str]cs$tt}d|kr |d|S)Nr)listrD__dir__remove)rF attributesrHrJrKr@s zModelMetaclass.__dir__)NTN)rLrMrNrtyping TYPE_CHECKINGr classmethodrr staticmethodrpropertyrrrrrrPrJrJrHrKrVOs("0 rVr7r;rdcCsPt|dddkrLi}|jD] \}}|}|tk r|||<qt|d|dS)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)rrkr get_defaultr object_setattr)rFreZpydantic_privater private_attrdefaultrJrJrKrfGs  rfrXrWzCallable[..., Any] | None)r^r]r>cCs2d|kr|dSt}t|d}||jk r.|SdS)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.riN)r%rri)r^r]r7rirJrJrKrYs   rzset[str]zdict[str, ModelPrivateAttr])r^rbase_class_varsbase_class_fieldsr>c s8ddlmm}t}|t}i}|di}d|ks@d|krHtdt} t| D]\} } | dksZ| dkrxqZqZt | t r| j |dkrd |kr| j |d rqZqZt | |s| jj d kr| | qZqZt | r,| d rtd | d n$t| rtdd| d| d | || <|| =qZt | |rjt| sj| dpPd} td| d| d qZ| d rzqZqZt| r| |kst|| s0t|| d|| <|| =qZ| |krqZqZ| |krZ| |krtd| dddqZt | |rtd| dddqZtd| d| d| dddqZ| D]\} }t| r:| |kr:| | kr:t|s:||kr:t|ddd kr:t |trtd}|dk rz tt|dd d!|j|jd"}Wnttfk rYnXt |r&t!|^}}t"fd#d$|Dd}|dk r&||| <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)r4r6rZ__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rcrrMrN functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of r{zJPrivate attributes must not use valid field names; use sunder names, e.g. _z instead of Zmy_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_argumentZis_class)globalnslocalnsc3s|]}t|r|VqdSrq)rA)rsr=r4rJrKrus z$inspect_namespace..)#fieldsr4r6r&default_ignored_typesr@rrrrrAr[rMrN startswithrIadd NameErrorr lstripr!r.r rrr9sys _getframer,r+ f_globalsf_localsr-rnext)r^rrrr6r3Zall_ignored_typesrZraw_annotations ignored_namesvar_namevalueZsuggested_nameZann_nameZann_typeframermetadatarrJrrKres                       rrl)rr]r>cCs<t|d}t|}|dtjhks2t|dd|jkr8||_dS)Nr__code__)rmake_hash_funcr:rrr)rr]Zbase_hash_funcZ new_hash_funcrJrJrKrs  r)rr>cs6|jrtj|jndddddfdd }|S)NcSsdS)NrrJ)rrJrJrKz make_hash_func..rint)rFr>cs<zt|jWStk r6tt|jYSXdSrq)hashrKeyErrorr1rgetterrJrK hash_funcsz!make_hash_func..hash_func)roperator itemgetterr)rrrJrrKrs rrzNsResolver | None)rr]rrr>c Cslt|}t|||||d\}}||_|j||D]2}|j|d}|dk r4|jtk r4t |||jq4dS)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$rrrjrrkrrr setattr) rr]rrrrrr<rrJrJrKr s rrr9rYrZ)rr\rrrrr>c Cs<|jrt||dSt|}t|||}tt|jdd|dd}z|||} WnDtk r} z&|rht||d| j dWYdSd} ~ XYnX|j |j d} z| | } Wn"|j k rt||YdSX| |_t| ||p|j|j|rdnd | |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)Zfrom_dunder_get_core_schemaunpack)Zref_moder?N)titleZ create_modelr7T __signature__)rRrpopulate_by_nameextra)Z defer_buildr'r$r"r)rZgenerate_schemaZ__get_pydantic_core_schema__rr core_configrLZ clean_schemaZCollectedInvalidZ__pydantic_core_schema__rrMrNZplugin_settingsrrZ__pydantic_serializer__rr0r*rrrrr) rr\rrrrrZ gen_schemahandlerZschemaerrJrJrKr+sd      rcCs|jD]6\}}|j}dk r t|}|||t|||q |jD]J\}}|j}dk rLtt|j dsLt||j }|||t|||qLdS)z8Set data descriptors on the class for deprecated fields.N__deprecated__) rrZdeprecation_message_DeprecatedFieldDescriptorrrrrrwrapped_property)rfieldZ field_infomsgdescZcomputed_field_inforJrJrKrs    rc@sfeZdZUdZded<ddddddd Zd ddd d d ZdddddddZddddddZdS)raWRead-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. r9 field_nameNzproperty | Noner;)r rr>cCs||_||_dSrq)r r)rFr rrJrJrKrsz#_DeprecatedFieldDescriptor.__init__rl)rrr>cCs ||_dSrq)r )rFrrrJrJrKrsz'_DeprecatedFieldDescriptor.__set_name__zBaseModel | Noneztype[BaseModel] | Noner)robj_typer>cCsb|dkr*|jdk r |jd|St|jtj|jtjdd|jdk rV|j||S|j |jS)Nrrm) r__get__rr rBrCr builtinsDeprecationWarningr)rFrr rJrJrKr s   z"_DeprecatedFieldDescriptor.__get__r )rrr>cCst|jdSrq)rr )rFrrrJrJrK__set__sz"_DeprecatedFieldDescriptor.__set__)N)N) rLrMrNrOrrrr rrJrJrJrKrs rc@s:eZdZdZddddZddddZd dd 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`). r)rcCs |dkrd|_n t||_dSrq)_wrweakrefref)rFrrJrJrKrsz_PydanticWeakRef.__init__rcCs|jdkrdS|SdSrq)rrrJrJrK__call__s z_PydanticWeakRef.__call__z4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrq)rrrJrJrK __reduce__sz_PydanticWeakRef.__reduce__N)rLrMrNrOrrrrJrJrJrKrsrzdict[str, Any] | None)dr>c CsT|dkr dSi}|D]6\}}z t|}Wntk rD|}YnX|||<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)rrr)rresultr<r=proxyrJrJrKrs   rcCsP|dkr dSi}|D]2\}}t|trB|}|dk rJ|||<q|||<q|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrAr)rrr<r=rJrJrKrs   r)maxsizercCs<ddlm}ttttt|tg}tj dkr4| t jt |S)Nr)r2) ) rr2rrrrrrr version_infoappendrr)r2rrJrJrKrs   r)jrO __future__rZ _annotationsrrrrrBrabcrrrrtypesrrrr r r r Z pydantic_corer rtyping_extensionsrrrrerrorsrrZplugin._schema_validatorrrr_configrZ _decoratorsrrrr_fieldsrr r!Z_generate_schemar"Z _genericsr#r$Z _import_utilsr%r&Z _mock_val_serr'Z_namespace_utilsr(Z_schema_generation_sharedr) _signaturer*Z _typing_extrar+r,r-r.r/Z_utilsr0r1rrr2r3r4r5ZPydanticModelFieldr6ZPydanticModelPrivateAttrmainr7rr: __setattr__rrr8rSrVrfrrrrrrrrrrrrrJrJrJrKsz              x   &]%#