o $6dIg@sXUdZddlmZddlZddlZddlZddlmZddl m Z ddl m Z ddlm Z mZmZmZddlmZmZmZdd lmZmZd d lmZmZd d lmZmZmZmZd d lm Z ddl!m"Z"ddl#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@mAZAddlBmCZCejDrddlEmFZFd dlGmHZHne ZIe eJeKeLe*e(eCfZMdeNd<eOjPZQGdd d eRZSed!efd"Gd#d$d$eZTdWd+d,ZUdXd5d6ZVdYd8d9ZWdZd?d@ZXd!dAd[dGdHZYd\dNdOZZGdPdQdQej[Z\d]dSdTZ]d]dUdVZ^dS)^z"Private logic for creating models.) annotationsN)ABCMeta)partial) FunctionType)AnyCallableGenericMapping)PydanticUndefinedSchemaSerializerSchemaValidator)dataclass_transform deprecated)PydanticUndefinedAnnotationPydanticUserError)Field FieldInfoModelPrivateAttr PrivateAttr)PydanticDeprecatedSince20) ConfigWrapper)collect_invalid_schemasflatten_schema_defsinline_schema_defs)ComputedFieldInfoDecoratorInfosPydanticDescriptorProxy)apply_discriminators)collect_model_fieldsis_valid_field_nameis_valid_privateattr_name)GenerateSchema)PydanticGenericMetadataget_model_typevars_map) MockValSerset_model_mocks)CallbackGetCoreSchemaHandler)get_cls_types_namespace is_classvarparent_frame_namespace)ClassAttributeis_valid_identifier)ValidateCallWrapper) Signature BaseModelztuple[Any, ...] IGNORED_TYPEScs"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 isinstancerwarningswarnZdecorator_infoZdecorator_reprsuper __setitem__)selfr4r6existing __class__}C:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\pydantic/_internal/_model_construction.pyr@:s z_ModelNamespaceDict.__setitem__)r4r5r6r7r8r9)__name__ __module__ __qualname____doc__r@ __classcell__rErErCrFr35sr3T)Zkw_only_defaultZfield_specifierscsxeZdZ  d%d&fdd Zejsd'ddZed(ddZd)fdd Z e d*ddZ e e d ed!d+d#d$ZZS),ModelMetaclassNTcls_namer5basestuple[type[Any], ...] namespacedict[str, Any]__pydantic_generic_metadata__PydanticGenericMetadata | None#__pydantic_reset_parent_namespace__boolkwargsrr8typec s|r9||\}}} t|||} | j|d<t|| j||} | r9d|vr5|dd'fd d } | |d<nt|d<||d <i| | |d <| jrMt||t j ||||fi|} d dl m }t | jdd | _| j|jurqdnd| _t| | _|r|| _nlt | diddt | ddprrtfddDstfddD}ddd|D}d|d}d|d}t|vrdd d|D|g}|d!| jd"|d#7}t|ddd$| _d| _| D] \}}|| |q|rt t!| _"t | d%d}t#|t$rt%|}t&| |}t'| || |t(| || d|d&t | | j)di|| St j ||||fi|S)(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. **kwargs: Catch-all for any other keyword arguments. Returns: The new class created by the metaclass. model_configmodel_post_initrAr1_ModelMetaclass__contextrr8r9cst||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rArZ)original_model_post_initrErFwrapped_model_post_initjs z7ModelMetaclass.__new__..wrapped_model_post_init__class_vars____private_attributes__rr0Z__pydantic_base_init__FNrR parametersrE__parameters__c3s|]}|vVqdSNrE.0x)r`rErF sz)ModelMetaclass.__new__..c3s|] }|vr|VqdSrbrErc)parent_parametersrErFrfsz, cSsg|]}t|qSrE)r5rcrErErF sz*ModelMetaclass.__new__..ztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSsg|]}|jqSrE)rGrcrErErFrhsz- Note: `typing.Generic` must go last: `class (z): ...`))originargsr`__pydantic_parent_namespace__) raise_errorstypes_namespace)rAr1rZrr8r9)*_collect_bases_datarZ for_modelZ config_dictinspect_namespace ignored_typesr[frozenset_default_hash_funcr?__new__mainr1getattr__init__Z__pydantic_custom_init__rYZ__pydantic_post_init__rbuildZ__pydantic_decorators__rRr;alltuplejoinrrG TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr+rnr<dictunpack_lenient_weakvaluedictr)set_model_fieldscomplete_model_classZ__pydantic_init_subclass__)mcsrMrNrPrRrTrVZbase_field_names class_varsZbase_private_attributesconfig_wrapperprivate_attributesr]clsr1Zcombined_parametersZparameters_strZgeneric_type_label error_messageZ bases_strnameobjZparent_namespacerprC)r\r`rgrFrvDs            zModelMetaclass.__new__itemcCs`|jd}|r||vr||S|dkr,t|dd}t|tr,|}|dur,t|dSt|)zNThis is necessary to keep attribute access working for class attribute access.r___pydantic_core_schema____pydantic_validator__N)__dict__r;rxr<r&ZrebuildAttributeError)rArrZmaybe_mock_validatorZrebuilt_validatorrErErF __getattr__s     zModelMetaclass.__getattr__rmMapping[str, object]cOstSrb)r3)rrmrVrErErF __prepare__szModelMetaclass.__prepare__instancecst|do t|S)zsAvoid calling ABC _abc_subclasscheck unless we're pretty sure. See #3829 and python/cpython#92810 r)hasattrr?__instancecheck__)rArrCrErFrsz ModelMetaclass.__instancecheck__6tuple[set[str], set[str], dict[str, ModelPrivateAttr]]cCspddlm}t}t}i}|D]"}t||r2||ur2|t|di||j||jq|||fS)Nrr0 model_fields) rwr1set issubclassupdaterxkeysr^r_)rNr1 field_namesrrbaserErErFrqs    z"ModelMetaclass._collect_bases_dataEThe `__fields__` attribute is deprecated, use `model_fields` instead.)categorydict[str, FieldInfo]cCstdt|jS)Nr)r=r>DeprecationWarningrrArErErF __fields__s zModelMetaclass.__fields__)NT)rMr5rNrOrPrQrRrSrTrUrVrr8rW)rr5r8r)rmrrVrr8r)rrr8rU)rNrOr8r)r8r)rGrHrIrvtyping TYPE_CHECKINGr classmethodrr staticmethodrqpropertyrrrrKrErErCrFrLBs ~   rLrAr1 __contextrr8r9cCs@i}|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 get_defaultr object_setattr)rArZpydantic_privaterZ private_attrdefaultrErErFr[s r[rPrQrsrObase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c Cs<|t}i}|di}d|vsd|vrtdt}t|D]\}} |dkr*q!t| tr?| j|dkr?| j |dr?q!t| |sJ| j jdkrP| |q!t| t r{| drbtd |d t|rstd d |d |d | ||<||=q!t| trt|s|d pd} td| d |d | drq!t|r||vst||st| d||<||=q!||vrq!||vr||vrtd|dddt| trtd|dddtd|d| d|dddq!|D]+\} } t| r| |vr| |vrt| s| |vrt| dddkrt|| <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. __annotations__Z__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rXrHrI functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of rjzJPrivate 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']`.N)r2r;r~rlistrr<rWrHrI startswithrDaddr NameErrorr!rlstripr"r*rrrx) rPrsrrZall_ignored_typesrZraw_annotations ignored_namesvar_namevalueZsuggested_nameZann_nameZann_typerErErFrrs            rrrNcCsTd|vrdSd}|D]}t|dt}|turnq |dur(ddd}||d<dSdS) N__hash__rArr8intcSst|jtt|jSrb)hashrDr|rvaluesrrErErF hash_funcsz(set_default_hash_func..hash_func)rArr8r)rxr )rPrNZbase_hash_funcrrrErErFruus   rurtype[BaseModel]rrrpc 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%r rr^rr_poprr setattr) rrNrrprfieldsrr4rrErErFrs  r)rorMr5rorUdict[str, Any] | Nonec Cst|}t|||}tt|jdd|dd}|jr t||dSz|||}Wn!tyI} z|r3t||d| j dWYd} ~ dSd} ~ ww| |} | |}t t |}t|ret||dS||_t|} t| | |_t| | |_d|_tdt|j|j||_dS) 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. 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:NT __signature__)r%r#r(rZgenerate_schemaZ defer_buildr'Z__get_pydantic_core_schema__rr core_configZcollect_definitionsrrrrrr rr Z__pydantic_serializer__rr,generate_model_signatureryrr) rrMrrorprZ gen_schemahandlerZschemaerZsimplified_core_schemarErErFrsL        rinitCallable[..., None]rrr/cCsddlm}m}m}ddlm}||j}i}d} d} ||ddD]} | jdkr0| j t d} | j | j ur9| } q#| || j <q#| r|j} |D]G\} }t|jtrV|j}n| }| |vs`||vraqHt|sq| rnt| rn| }nd } qH|rwind |jdd i}|||jfd |i|||<qH|jd krd } | r| rd|jfd|j fg}dd|D|krd}n| j }||vr|d7}||vs| j |d||<|t|ddS)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) Parameterr/ signature)isliceNFrr) annotationTr)Zcall_default_factoryrZallowZ__pydantic_self__datacSsg|]}|j|jfqSrE)rkind)rdprErErFrh2sz,generate_model_signature.. extra_datar)r)r`return_annotation)inspectrr/r itertoolsrr`rrreplacerr VAR_KEYWORDrZpopulate_by_namerr<aliasr5r-Z is_requiredr KEYWORD_ONLYZrebuild_annotationextraPOSITIONAL_OR_KEYWORDr)rrrrr/rrZpresent_paramsZ merged_paramsZvar_kwZ use_var_kwparamZ allow_names field_namefield param_namerVZdefault_model_signatureZ var_kw_namerErErFrs`        rc@s eZdZdS)_PydanticWeakRefN)rGrHrIrErErErFrAsrdc 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)rrr~)rresultr4r6proxyrErErFrEs   rcCsP|durdSi}|D]\}}t|tr!|}|dur |||<q |||<q |S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rr<r)rrr4r6rErErFrYs  r)rAr1rrr8r9) rPrQrsrOrrrrr8r)rPrQrNrOr8r9) rrrNrOrrrprQr8r9) rrrMr5rrrorUrprr8rU)rrrrrrr8r/)rrr8r)_rJ __future__rZ _annotationsrr=weakrefabcrrrtypesrrrrr Z pydantic_corer r r Ztyping_extensionsr rerrorsrrrrrrrr_configrZ _core_utilsrrrZ _decoratorsrrrZ_discriminated_unionr_fieldsr r!r"Z_generate_schemar#Z _genericsr$r%Z _mock_val_serr&r'Z_schema_generation_sharedr(Z _typing_extrar)r*r+_utilsr,r-Z_validate_callr.rrr/rwr1rrrrr2rr7 __setattr__rrr3rLr[rrrurrr ReferenceTyperrrrErErErFsj               5  m # JP