o #j@sdZddlmZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z mZddlmZddlmZmZmZmZmZmZmZmZddlmZmZdd lmZmZmZm Z m!Z!dd l"m#Z#d d l$m%Z%m&Z&d d l'm(Z(d dlm)Z)m*Z*ddl+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8m9Z9ddl:m;Z;mZ>m?Z?ddl@mAZAddlBmCZCddlDmEZEddlFmGZGmHZHmIZImJZJddlKmLZLmMZMerd dlNmOZPd dlNmQZQmRZRd dlNmSZTd dlUmVZVddl2mWZWneXZPeXZTeXjYZZGd d!d!e[Z\d"d#dgd(d)Z]ed*Z^ed+ePeTe]fd,Gd-d.d.e Z_dhd3d4Z`did:d;ZadjdBdCZbdkdFdGZcdldHdIZddmdNdOZed+d+dd"dPdndWdXZfdodYdZZgGd[d\d\ZhGd]d^d^ZidpdadbZjdpdcddZke dqdedfZldS)rz"Private logic for creating models.) annotationsN)ABCMeta)cachepartialwraps) FunctionType) TYPE_CHECKINGAnyCallableGenericLiteralNoReturnTypeVarcast)PydanticUndefinedSchemaSerializer) TypeAliasTypedataclass_transform deprecatedget_args get_origin)typing_objects)PydanticUndefinedAnnotationPydanticUserError)create_schema_validator)GenericBeforeBaseModelWarningPydanticDeprecatedSince20) ConfigWrapper)DecoratorInfosPydanticDescriptorProxyget_attribute_from_basesunwrap_wrapped_function)collect_model_fieldsis_valid_field_nameis_valid_privateattr_namerebuild_model_fields)GenerateSchemaInvalidSchemaError)PydanticGenericMetadataget_model_typevars_map)import_cached_base_modelimport_cached_field_info)set_model_mocks) NsResolver)generate_pydantic_signature)_make_forward_refeval_type_backportis_classvar_annotationparent_frame_namespace)LazyClassAttributeSafeGetItemProxy)Field) FieldInfoModelPrivateAttr) PrivateAttr) BaseModel)PydanticExtraInfocs"eZdZdZd fdd ZZS) _ModelNamespaceDictz{A dictionary subclass that intercepts attribute setting on model classes and warns about overriding of decorators. kstrvobjectreturnNonecsP||d}|r!||ur!t|tr!tjd|d|jjdddt||S)N`z"` overrides an existing Pydantic `z ` decoratorr stacklevel) get isinstancer!warningswarnZdecorator_infoZdecorator_reprsuper __setitem__)selfr>r@existing __class__g/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/pydantic/_internal/_model_construction.pyrL9s z_ModelNamespaceDict.__setitem__)r>r?r@rArBrC)__name__ __module__ __qualname____doc__rL __classcell__rQrQrOrRr=4sr=FinitrYLiteral[False]rBr cCdS)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. NrQrXrQrQrR NoInitFieldDr\_TT)Zkw_only_defaultZfield_specifierscseZdZ   d-d.fdd Zesd/ddZed0ddZd1fdd Ze j Z e j Z e d2d!d"Z eed#dd$d3d&d'Zed4d(d)Zd5fd+d, ZZS)6ModelMetaclassNTcls_namer?basestuple[type[Any], ...] namespacedict[str, Any]__pydantic_generic_metadata__PydanticGenericMetadata | None#__pydantic_reset_parent_namespace__bool_create_model_module str | Nonekwargsr rBtypec" s|rtjdkr,d|vr|d}n!ddlm} m} m} | |} r)| | | jd}n i}n|di}||\} }}t ||||}|j |d<t |||j || }|sT|rqt||durmtd<fdd }||d<nt|d<||d<i|||d<tdtj||||fi|}t}|j}t|vr|t||krtjtdddt|jdd |_|j|jurdnd|_i|_ t!j"|dd|_#|j#$||r||_%nt|diddt|ddprnrnt&fdd Dsndd!l'm(}t)fd"d D}|vr2|vr2d#*d$d%|D}|j+d&|d'|j+d(|d)}t,||}d#*d*d%|D}d+|d,}d-|d.}t|vrjd#*d/d%|D|g}|d0|j+d1|d27}t,|ddd3|_%d|_-|.D] \}}|/||q||rt0t1|_2t|d4d}t3|t4rt5|}t6|d5} t7||| d6d7d8|j#j8.D|_9|j:rt;|n t<||| d|d9|j=rd:|vrt>||t||j?di||Sd;D] }!|@|!dq|diAtj||||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. _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. )__annotations__r)Formatcall_annotate_function!get_annotate_from_class_namespace)format model_configNrMr;contextr rBrCcst||||dS)zWe need to both initialize private attributes and call the user-defined model_post_init method. N)init_private_attributes)rMru)original_model_post_initrQrRwrapped_model_post_inits 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.rrEZ__pydantic_base_init__FT)Zreplace_wrapped_methodsre parametersrQ__parameters__c3s|]}|vVqdSNrQ.0x)r}rQrR sz)ModelMetaclass.__new__..)RootModelRootTypec3s|] }|vr|VqdSrrQr)parent_parametersrQrRrsz, cSg|]}|jqSrQrSrrQrQrR 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|qSrQ)r?rrQrQrRrsztyping.Generic[]zJAll parameters must be present on typing.Generic; you should inherit from .cSrrQrrrQrQrRrrz- Note: `typing.Generic` must go last: `class (z): ...`))originargsr}__pydantic_parent_namespace__)parent_namespace)config_wrapper ns_resolvercSi|]\}}||jqSrQinforr>r@rQrQrR s z*ModelMetaclass.__new__..) raise_errorscreate_model_module__hash__)Z__pydantic_fields_set____pydantic_extra____pydantic_private__rMr;rur rBrC)Bsys version_infoZ annotationlibrprqrrZ FORWARDREFrG_collect_bases_datarZ for_modelZ config_dictinspect_namespace ignored_typesget_model_post_initrrvrrK__new__r,__mro__r indexrIrJrgetattr__init__Z__pydantic_custom_init__ryZ__pydantic_post_init__Z__pydantic_setattr_handlers__r build__pydantic_decorators__Zupdate_from_configreallZ root_modelrtuplejoinrS TypeError__pydantic_complete__items __set_name__build_lenient_weakvaluedictr4rrHdictunpack_lenient_weakvaluedictr/set_model_fieldscomputed_fields__pydantic_computed_fields__Z defer_buildr.complete_model_classfrozenset_default_hash_funcZ__pydantic_init_subclass__popclear)"mcsr`rarcrergrirkraw_annotationsrprqrrZannotateZbase_field_names class_varsZbase_private_attributesrprivate_attributesrxclsZ BaseModel_mrorZmissing_parametersZparameters_str error_messageZcombined_parametersZgeneric_type_labelZ bases_strnameobjrrZ instance_slotrO)rwr}rrRrTs          $          zModelMetaclass.__new__itemcCs(|jd}|r||vr||St|)zNThis is necessary to keep attribute access working for class attribute access.r{)__dict__rGAttributeError)rMrrrQrQrR __getattr__s  zModelMetaclass.__getattr__rdict[str, object]cOstSr)r=)rrrkrQrQrR __prepare__$szModelMetaclass.__prepare__subclasstype[_T]cs$tjd|jdddt|S)Nz>For performance reasons, virtual subclasses registered using 'zK.register()' are not supported in 'isinstance()' and 'issubclass()' checks.rrE)rIrJrUrKregister)rMrrOrQrRr,s   zModelMetaclass.register6tuple[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 issubclassupdaterkeysrzr{)rar; field_namesrrbaserQrQrRr7s   z"ModelMetaclass._collect_bases_dataXThe `__fields__` attribute is deprecated, use the `model_fields` class property instead.)categorydict[str, FieldInfo]cCstjdtddt|diS)NrrrEr)rIrJrrrMrQrQrR __fields__Fs  zModelMetaclass.__fields__cCsTd|jvrdStd|j}td|j}|dur|j}nd}tdd|Do)|S) zWhether the fields were successfully collected (i.e. type hints were successfully resolved). This is a private attribute, not meant to be used outside Pydantic. rFrzPydanticExtraInfo | NoneNTcss|]}|jVqdSr)Z _complete)r field_inforQrQrRrcsz>ModelMetaclass.__pydantic_fields_complete__..)rrr__pydantic_extra_info__Zcompletervalues)rMZ field_infospydantic_extra_infoZextra_completerQrQrR__pydantic_fields_complete__Rs   z+ModelMetaclass.__pydantic_fields_complete__ list[str]cs$tt}d|vr|d|S)Nr)listrK__dir__remove)rM attributesrOrQrRres zModelMetaclass.__dir__)NTN)r`r?rarbrcrdrerfrgrhrirjrkr rBrl)rr?rBr )rr rkr rBr)rrrBr)rarbrBr)rBr)rBrh)rBr)rSrTrUrrr classmethodrrrl__instancecheck____subclasscheck__ staticmethodrpropertyrrrrrWrQrQrOrRr_Rs.G    r_rMr;rurCcCsxt|dddur:i}|jD]"\}}|jr#|jdi|j|d}n|jdd}|tur1|||<qt|d|dSdS)a This function is meant to behave like a BaseModel method to initialize 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. rNT)call_default_factoryZvalidated_data)r)rr{rZ$default_factory_takes_validated_data get_defaultrrobject_setattr)rMruZpydantic_privater private_attrdefaultrQrQrRrvls  rvrcrdrarbCallable[..., 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.ryN)r,r"ry)rcrar;ryrQrQrRrs  rrrbase_class_varsset[str]base_class_fieldsdict[str, ModelPrivateAttr]c s ddlmm}t}|t}i}d|vsd|vrtdt} t|D]\} } | dks3| dkr4q't | t rP| j |dkrPd|vrP| j |dd rPq't | |s[| jj d kra| | q't | r| d rstd | d t| rtd d| 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 |trWtd}|durWztt|ddd |j|jd!}Wn ttfyVYnwt t!|r|t"|^}}t#fd"d#|Dd}|dur|||| <q||| <q|S)$aLIterate 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. raw_annotations: The (non-evaluated) annotations of the model. 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 containing 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)r9r:Z__root__zUTo define root models, use `pydantic.RootModel` rather than a field called '__root__'rtrrTrUr functools__zXPrivate attributes must not use dunder names; use a single underscore prefix instead of 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_argumentis_class)globalnslocalnsc3s|] }t|r|VqdSr)rH)rr@r9rQrRrsz$inspect_namespace..)$fieldsr9r:r-default_ignored_typesrrrrrHrlrTrU startswithrPadd NameErrorr%lstripr&r3rrrr?r _getframer2r1 f_globalsf_localsrZ is_annotatedrrnext)rcrrrrr:r8Zall_ignored_typesr ignored_namesvar_namevalueZsuggested_nameZann_nameZann_typeframermetadatarrQrrRrs                   rrr|cCs@t|d}t|}|dtjhvst|dd|jkr||_dSdS)Nr__code__)r"make_hash_funcrArrr )rraZbase_hash_funcZ new_hash_funcrQrQrRrs   rcs0|jr tj|jnddd fdd }|S) NcSr[)NrrQ)rrQrQrR'r]z make_hash_func..rMr rBintcs6zt|jWStytt|jYSwr)hashrKeyErrorr6rgetterrQrR hash_func)s  z!make_hash_func..hash_func)rMr rBr)roperator itemgetterr)rrrQrrRr&s rrrrr/c Csrt|}t||||d\}}}||_||_|j||D]}|j|d}|dur6|jt ur6t |||jqdS)zCollect and set `cls.__pydantic_fields__` and `cls.__class_vars__`. Args: cls: BaseModel or dataclass. config_wrapper: The config wrapper instance. ns_resolver: Namespace resolver to use when getting model annotations. ) typevars_mapN) r+r$rrrzrr{rrrsetattr) rrrrrrrr>r rQrQrRr6s   r)rcall_on_complete_hookris_force_rebuildrrhrrrjrc Cst|}|jsHzt||||d\|_|_Wn&ty;}zt|} t|d| j d|r1| |WYd}~nd}~ww|sC|jsCdS|jsHJt |||} z| |} Wn tyu}z|r`t|d|j dWYd}~dSd}~ww|j |j d} z| | } Wntyt|YdSwdd|jjD|_t|| |_t| ||p|j|j|rdnd | |j| d |_t| | | d |_td tt|j |j|j!|j"d |_#d |_$|r|%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. config_wrapper: The config wrapper instance. ns_resolver: The namespace resolver instance to use during schema building. raise_errors: Whether to raise errors. call_on_complete_hook: Whether to call the `__pydantic_on_complete__` hook. create_model_module: The module of the class to be created, if created by `create_model`. is_force_rebuild: Whether the model is being force-rebuilt (if True, pre-built serializers and validators are not used, to avoid stale references). Returns: `True` if the model is successfully completed, else `False`. Raises: PydanticUndefinedAnnotation: If PydanticUndefinedAnnotation occurs in __get_pydantic_core_schema__ and `raise_errors=True`. )rrrrDNF)titlecSrrQrrrQrQrRrsz(complete_model_class..Z create_modelr;)Z _use_prebuilt __signature__)rYrvalidate_by_nameextraT)&r+rr'rrrrZfrom_name_errorr.rr(Zgenerate_schema core_configrSZ clean_schemar)rrrrset_deprecated_descriptorsZ__pydantic_core_schema__rrTrUZplugin_settingsZ__pydantic_validator__rZ__pydantic_serializer__r5rr0rrrrrZ__pydantic_on_complete__) rrrrrrrreexcZ gen_schemaZschemar rQrQrRrXs         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.NZ__deprecated__) rrZdeprecation_message_DeprecatedFieldDescriptorrrrhasattrr#wrapped_property)rfieldrmsgdescZcomputed_field_inforQrQrRr!s     r!c@sFeZdZUdZded<ddd d ZdddZddddZd ddZdS)!r$aWRead-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_nameNr(r&property | NonerBrCcCs||_||_dSr)r(r&)rMr(r&rQrQrRrs z#_DeprecatedFieldDescriptor.__init__rr|rcCs ||_dSr)r*)rMrrrQrQrRr z'_DeprecatedFieldDescriptor.__set_name__rBaseModel | Noneobj_typetype[BaseModel] | Noner cCs`|dur|jdur|jd|St|jtj|jtdd|jdur*|j||S|j|jS)NrrE) r&__get__rr*rIrJr(DeprecationWarningr)rMrr.rQrQrRr0s    z"_DeprecatedFieldDescriptor.__get__r r cCs t|jr)rr*)rMrr rQrQrR__set__r,z"_DeprecatedFieldDescriptor.__set__r)r(r?r&r+rBrC)rr|rr?rBrC)rr-r.r/rBr )rr r r rBr ) rSrTrUrVrorrr0r2rQrQrQrRr$s    r$c@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 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`). rr cCs"|dur d|_dSt||_dSr)_wrweakrefref)rMrrQrQrRrs z_PydanticWeakRef.__init__rBcCs|jdurdS|Sr)r4rrQrQrR__call__%s z_PydanticWeakRef.__call__4tuple[Callable, tuple[weakref.ReferenceType | None]]cCs t|ffSr)r3rrQrQrR __reduce__+s z_PydanticWeakRef.__reduce__N)rr )rBr )rBr8)rSrTrUrVrr7r9rQrQrQrRr3 s   r3ddict[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)rr3r)r:resultr>r@proxyrQrQrRr/s   rcCsP|durdSi}|D]\}}t|tr!|}|dur |||<q |||<q |S)zAInverts the transform performed by `build_lenient_weakvaluedict`.N)rrHr3)r:r<r>r@rQrQrRrCs  rcCs<ddlm}ttttt|tg}tj dkr| t jt |S)Nr)ComputedFieldInfo)rm ) rr>rrrrr!rrrappendtypingr)r>rrQrQrRrSs  r)rYrZrBr r)rcrdrarbrBr) rcrdrrdrrbrrrrrBr)rr|rarbrBrC)rr|rBr )rr|rrrr/rBrC)rr|rrrr/rrhrrhrrjrrhrBrh)rr|rBrC)r:r;rBr;)rBrb)mrV __future__rZ _annotationsrrrArIr5abcrrrrrtypesrrr r r r r rrZ pydantic_corerrZtyping_extensionsrrrrrZtyping_inspectionrerrorsrrZplugin._schema_validatorrrr_configrZ _decoratorsr r!r"r#_fieldsr$r%r&r'Z_generate_schemar(r)Z _genericsr*r+Z _import_utilsr,r-Z _mock_val_serr.Z_namespace_utilsr/ _signaturer0Z _typing_extrar1r2r3r4Z_utilsr5r6rr7ZPydanticModelFieldr8r9r:ZPydanticModelPrivateAttrmainr;r<rA __setattr__rrr=r\r^r_rvrrrrrrr!r$r3rrrrQrQrQrRs   (              ' |% #