a y{Jh!j @sdZddlmZddlZddlZddlZddlmZddl m Z ddl m Z ddlm Z mZmZmZddlZddlmZmZdd lmZmZd d lmZmZd d lmZd d lmZmZddlmZddl m!Z!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ej<rddl=m>Z>d dl?m@ZAd dl?mBZBmCZCd dlDmEZEn eZFeGZAeGjHZIGdddeJZKedeAfd Gd!d"d"eZLd#d$d%d&d'd(ZMd)d*d+d,d-d.ZNd)d*d/d/d0d1d2d3ZOd)d*d%d,d4d5ZPd6d*d7d)d%d8d9d:ZQddd;d6dd?d=d@dAdBZRdCdDd7dEdFdGdHZSGdIdJdJZTd>d>dKdLdMZUd>d>dKdNdOZVd*dPdQdRZWdS)Sz"Private logic for creating models.) annotationsN)ABCMeta)partial) FunctionType)AnyCallableGenericMapping)PydanticUndefinedSchemaSerializer)dataclass_transform deprecated)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_bases)collect_model_fieldsis_valid_field_nameis_valid_privateattr_name)GenerateSchemagenerate_pydantic_signature)PydanticGenericMetadataget_model_typevars_map) MockValSerset_model_mocks)CallbackGetCoreSchemaHandler)get_cls_types_namespace is_annotated is_classvarparent_frame_namespace)ClassAttribute)ValidateCallWrapper) Signature)Field) FieldInfoModelPrivateAttr BaseModelcs*eZdZdZddddfdd ZZS)_ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. strobjectNone)kvreturncsL||d}|r>||ur>t|tr>td|d|jjdt||S)N`z"` overrides an existing Pydantic `z ` decorator) get isinstancerwarningswarnZdecorator_infoZdecorator_reprsuper __setitem__)selfr3r4existing __class__X/var/www/shaz/venv/lib/python3.9/site-packages/pydantic/_internal/_model_construction.pyr<2s z_ModelNamespaceDict.__setitem__)__name__ __module__ __qualname____doc__r< __classcell__rArAr?rBr/-sr/T)kw_only_defaultfield_specifiersc seZdZd"ddddddd d d fd d Zejs@dd dddZed d ddddZd ddfdd Z e dddddZ e e dedddd d!ZZS)#ModelMetaclassNTr0tuple[type[Any], ...]dict[str, Any]zPydanticGenericMetadata | Nonebool str | Nonertype)cls_namebases namespace__pydantic_generic_metadata__#__pydantic_reset_parent_namespace___create_model_modulekwargsr5c s|r||\}} } t|||} | j|d<t|| j| |} | r|t||durtddddfdd } | |d <nt|d <| |d <i| | |d <| jrt ||t j ||||fi|}d d l m }|j}t|vr|t||krtjtdd dt|jdd |_|j|jur"dnd |_t||_|rB||_nt|diddt|ddpfrrtfddDstfddD}d dd|D}d|d}d|d}t|vrd d d|D|g}|d!|j!d"|d#7}t"|ddd$|_d|_#| $D]\}}|%||q2|r\t&t'|_(t|d%d}t)|t*r|t+|}t,||}t-||| |t.||| d||d&t ||j/fi||St j ||||fi|SdS)'aMetaclass for creating Pydantic models. Args: cls_name: The name of the class to be created. bases: The base classes of the class to be created. namespace: The attribute dictionary of the class to be created. __pydantic_generic_metadata__: Metadata for generic models. __pydantic_reset_parent_namespace__: Reset parent namespace. _create_model_module: The module of the class to be created, if created by `create_model`. **kwargs: Catch-all for any other keyword arguments. Returns: The new class created by the metaclass. model_configNr.rr2)r=_ModelMetaclass__contextr5cst||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)r=rX)original_model_post_initrArBwrapped_model_post_initds z7ModelMetaclass.__new__..wrapped_model_post_initmodel_post_init__class_vars____private_attributes__rr-zClasses should inherit from `BaseModel` before generic classes (e.g. `typing.Generic[T]`) for pydantic generics to work properly.) stacklevelZ__pydantic_base_init__FrS parametersrA__parameters__c3s|]}|vVqdSNrA.0x)r`rArB z)ModelMetaclass.__new__..c3s|]}|vr|VqdSrbrArc)parent_parametersrArBrfrgz, cSsg|] }t|qSrA)r0rcrArArB rgz*ModelMetaclass.__new__..ztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSsg|] }|jqSrA)rCrcrArArBrirgz- Note: `typing.Generic` must go last: `class (z): ...`))originargsr`__pydantic_parent_namespace__) raise_errorstypes_namespacecreate_model_module)0_collect_bases_datarZ for_modelZ config_dictinspect_namespace ignored_typesget_model_post_initrYfrozenset_default_hash_funcr;__new__mainr.__mro__rindexr9r:rgetattr__init__Z__pydantic_custom_init__r\Z__pydantic_post_init__rbuildZ__pydantic_decorators__rSr7alltuplejoinrC TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr&ror8dictunpack_lenient_weakvaluedictr#set_model_fieldscomplete_model_classZ__pydantic_init_subclass__)mcsrPrQrRrSrTrUrVZbase_field_names class_varsZbase_private_attributesconfig_wrapperprivate_attributesr[clsr.mroZcombined_parametersZparameters_strZgeneric_type_label error_messageZ bases_strnameobjZparent_namespacerqr?)rZr`rhrBry<s       $       zModelMetaclass.__new__)itemr5cCsd|jd}|r ||vr ||S|dkrXt|dd}t|trX|}|durXt|dSt|dS)zNThis is necessary to keep attribute access working for class attribute access.r^__pydantic_core_schema____pydantic_validator__N)__dict__r7r}r8r ZrebuildAttributeError)r=rrZmaybe_mock_validatorZrebuilt_validatorrArArB __getattr__s     zModelMetaclass.__getattr__zMapping[str, object])rnrVr5cOstSrb)r/)rrnrVrArArB __prepare__szModelMetaclass.__prepare__)instancer5cst|dot|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 r)hasattrr;__instancecheck__)r=rr?rArBrsz ModelMetaclass.__instancecheck__z6tuple[set[str], set[str], dict[str, ModelPrivateAttr]])rQr5cCspddlm}t}t}i}|D]D}t||r ||ur |t|di||j||jq |||fS)Nrr- model_fields) rzr.set issubclassupdater}keysr]r^)rQr. field_namesrrbaserArArBrss  z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]r5cCstdt|jS)Nr)r9r:DeprecationWarningrr=rArArB __fields__s zModelMetaclass.__fields__)NTN)rCrDrErytyping TYPE_CHECKINGr classmethodrr staticmethodrspropertyr rrrGrArAr?rBrJ:s"" rJr.rr2)r= __contextr5cCsPt|dddurLi}|jD] \}}|}|tur|||<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. Z__pydantic_private__N)r}r^r get_defaultr object_setattr)r=rZpydantic_privater private_attrdefaultrArArBrYs  rYrLrKzCallable[..., Any] | None)rRrQr5cCs8d|vr|dSddlm}t|d}||jur4|SdS)zaGet the `model_post_init` method from the namespace or the class bases, or `None` if not defined.r\rr-N)rzr.rr\)rRrQr.r\rArArBrvs    rvzset[str]zdict[str, ModelPrivateAttr])rRrubase_class_varsbase_class_fieldsr5c sddlm}mm}|t}i}|di}d|vs>d|vrFtdt} t| D]\} } | dkrnqXqXt | t r| j |dkr| j |drqXqXt | |s| jj d kr| | qXqXt | r| d rtd | d n$t| r td d| d| d | || <|| =qXt | |rXt| sX| dp>d} td| d| d qX| d rhqXqXt| r| |vst|| s|| d|| <|| =qX| |vrqXqX| |vrX| |vrtd| dddqXt | |rtd| dddqXtd| d| d| dddqX| D]\} }t| r"| |vr"| | vr"t|s"||vr"t|ddd kr"t|rt|^}}tfdd|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)r+r, PrivateAttr__annotations__Z__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rWrDrE functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rkzJPrivate 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']`.Nc3s|]}t|r|VqdSrb)r8)rdr4r,rArBrfrgz$inspect_namespace..)fieldsr+r,rdefault_ignored_typesr7rrlistrr8rOrDrE startswithr@add NameErrorrlstriprr%rr}r$typing_extensionsget_argsnext)rRrurrr+rZall_ignored_typesrZraw_annotations ignored_namesvar_namevalueZsuggested_nameZann_nameZann_typermetadatarrArrBrts                rtcCs@d|vr dSt|d}|dtjhvr.hash_func)rr1r)rRrQZbase_hash_funcrrArArBrxs  rxztype[BaseModel]r)rrQrrqr5c Cslt|}t|||||d\}}||_|j||D]2}|j|d}|dur4|jtur4t |||jq4dS)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) rrrr]rr^poprr setattr) rrQrrqrrrr3rrArArBrs  r)rprrr0rMzdict[str, Any] | NonerN)rrPrrprqrrr5c Cs*t|}t|||}tt|jdd|dd}|jr@t||dSz|||} WnBty} z*|rft||d| j dWYd} ~ dSd} ~ 00| |} z| | } Wn |j yt||YdS0| |_ t| ||p|j|j|rdnd| |j|_t| | |_d |_td t|j|j||_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)Zfrom_dunder_get_core_schemaunpack)Zref_moder6NZ create_modelr.T __signature__)rrr"rZgenerate_schemaZ defer_buildr!Z__get_pydantic_core_schema__rr core_configZ clean_schemaZCollectedInvalidrrrDrEZplugin_settingsrr Z__pydantic_serializer__rr'generate_model_signaturer~rr) rrPrrprqrrrZ gen_schemahandlerZschemaerrArArBrsV      rzCallable[..., None]rr))initrrr5cCs t|||S)zGenerate signature for model based on its fields. Args: init: The class init. fields: The model fields. config_wrapper: The config wrapper instance. Returns: The model signature. )r)rrrrArArBrs 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 |durd|_n t||_dSrb)_wrweakrefref)r=rrArArBr~1sz_PydanticWeakRef.__init__rcCs|jdurdS|SdSrb)rrrArArB__call__9s z_PydanticWeakRef.__call__z4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSrb)rrrArArB __reduce__?sz_PydanticWeakRef.__reduce__N)rCrDrErFr~rrrArArArBr sr)dr5c CsR|dur dSi}|D]4\}}z t|}WntyB|}Yn0|||<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)rresultr3r4proxyrArArBrCs    rcCsP|dur dSi}|D]2\}}t|trB|}|durJ|||<q|||<q|S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr8r)rrr3r4rArArBrWs   rrcCsddlm}ttttt|tfS)NrComputedFieldInfo)rrrrrrrr(rrArArBrgs r)XrF __future__rZ _annotationsrr9rabcrrrtypesrrrrr rZ pydantic_corer r r r errorsrrZplugin._schema_validatorrrr_configrZ _decoratorsrrr_fieldsrrrZ_generate_schemarrZ _genericsrrZ _mock_val_serr r!Z_schema_generation_sharedr"Z _typing_extrar#r$r%r&Z_utilsr'Z_validate_callr(rinspectr)rr*ZPydanticModelFieldr+r,rzr.rr1 __setattr__rrr/rJrYrvrtrxrrrrrrrrArArArBsb            B u#T#