o #jW>@sUdZddlmZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZmZmZddl mZddlmZddlmZdd lmZdd lmZdd lmZmZmZmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5e#ree6e$fee7e$fBZ8de9d<ee6ee7BZ:de9d<ddl;me7e?e@eAe3jBeee ejCee!eDjEeFjEhZGde9d<eHeIeJeKeLe e e hZMde9d<dgdd ZNdhd#d$ZOdid(d)ZPdjd+d,ZQdkd.d/ZRdld2d3ZSe&d4ZTdmd8d9ZUdnd=d>ZVe&d?ZWe7d@dodFdGZXGdHdIdIe2jYZZe#r)dpdMdNZ[nGdOdNdNZ[e&dPZ\dqdRdSZ]e^Z_drdWdXZ`dsd[d\Zaejbd]d^Gd_d`d`Zce&dadbdcZde&ddZeGdedfdfe%edeefZfdS)tzBucket of reusable internal utilities. This should be reduced as much as possible with functions only used in one place, moved to that place. ) annotationsN) OrderedDict defaultdictdeque)CallableIterableMapping)Set)deepcopy)cached_property) Parameter) zip_longest)BuiltinFunctionTypeCodeType FunctionType GeneratorType LambdaType ModuleType) TYPE_CHECKINGAnyGenericTypeVaroverload)MISSINGPydanticUndefined) TypeAlias TypeGuard deprecated)PydanticDeprecatedSince211)_repr _typing_extra)import_cached_base_modelrMappingIntStrAnyAbstractSetIntStr) BaseModelzset[type[Any]]IMMUTABLE_NON_COLLECTIONS_TYPESBUILTIN_COLLECTIONSparamr returnboolcCs|jtjtjfvS)aZReturn whether the parameter accepts a positional argument. ```python {test="skip" lint="skip"} def func(a, /, b, *, c): pass params = inspect.signature(func).parameters can_be_positional(params['a']) #> True can_be_positional(params['b']) #> True can_be_positional(params['c']) #> False ``` )kindr POSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)r)r/Z/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/pydantic/_internal/_utils.pycan_be_positionalJsr1vrcCst|ttttttfSN) isinstancelisttupleset frozensetrrr2r/r/r0 sequence_like]sr:oclass_or_tuple(type[Any] | tuple[type[Any], ...] | NonecCs"zt||WStyYdSwNF)r4 TypeError)r;r<r/r/r0lenient_isinstanceas   r@clscCs:z t|to t||WStyt|tjrYdSwr>)r4type issubclassr?r!Z WithArgsTypes)rAr<r/r/r0lenient_issubclasshs  rDTypeGuard[type[BaseModel]]cCst}t||o ||uS)zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, unlike raw calls to lenient_issubclass. )r"rD)rAr&r/r/r0is_model_classqsrF identifierstrcCs|o t| S)zChecks that a string is a valid identifier and not a Python keyword. :param identifier: The identifier to test. :return: True if the identifier is valid. ) isidentifierkeyword iskeyword)rGr/r/r0is_valid_identifierzsrLKeyTypemappingdict[KeyType, Any]updating_mappingscGsd|}|D])}|D]"\}}||vr*t||tr*t|tr*t|||||<q |||<q q|Sr3)copyitemsr4dict deep_update)rNrPZupdated_mappingZupdating_mappingkr2r/r/r0rTs  rTdict[Any, Any]updateNonecKs|dd|DdS)NcSsi|] \}}|dur||qSr3r/).0rUr2r/r/r0 sz#update_not_none..)rWrR)rNrWr/r/r0update_not_nonesr[T) name_factory input_listlist[T] | tuple[T, ...]r]Callable[[T], str]list[T]cCsJg}g}|D]}||}||vr||||q||||<q|S)zMake a list unique while maintaining order. We update the list if another one with the same name is set (e.g. model validator overridden in subclass). )appendindex)r^r]resultZ result_namesr2Zv_namer/r/r0 unique_lists   rec@seZdZdZdZd-d d Zd.d dZd.ddZd/ddZd0ddZ e d1d2d d!Z e d3d"d#Z e d4d$d%Ze d5d'd(Zd6d*d+Zd,S)7 ValueItemszOClass for more convenient calculation of excluded or included fields on values.)_items_typevaluerrR$AbstractSetIntStr | MappingIntStrAnyr*rXcCs2||}t|ttfr||t|}||_dSr3) _coerce_itemsr4r5r6_normalize_indexeslenrg)selfrirRr/r/r0__init__s  zValueItems.__init__itemr+cCs||j|S)zWCheck if item is fully excluded. :param item: key or index of a value )is_truerggetrnrpr/r/r0 is_excludedszValueItems.is_excludedcCs ||jvS)z`Check if value is contained in self._items. :param item: key or index of value rgrsr/r/r0 is_includeds zValueItems.is_includede int | str+AbstractSetIntStr | MappingIntStrAny | NonecCs|j|}||s |SdS)z:param e: key or index of element on value :return: raw values for element if self._items is dict and contain needed element N)rgrrrq)rnrwrpr/r/r0 for_elements zValueItems.for_elementr#v_lengthintdict[int | str, Any]c Csi}d}|D]F\}}t|ts&t|ts&||s&td|d|j|dkr0||}qt|ts9td|dkrA||n|}| || |||<q|sS|S||rgt |D]}| |dq\|St |D]}| |i}||s| ||||<qk|S)a]:param items: dict or set of indexes which will be normalized :param v_length: length of sequence indexes of which will be >>> self._normalize_indexes({0: True, -2: True, -1: True}, 4) {0: True, 2: True, 3: True} >>> self._normalize_indexes({'__all__': True}, 4) {0: True, 1: True, 2: True, 3: True} Nz,Unexpected type of exclude value for index "z" __all__zExcluding fields from a sequence of sub-models or dicts must be performed index-wise: expected integer keys or keyword "__all__"r.) rRr4r AbstractSetrqr? __class__ _coerce_valuer|mergerrrange setdefault) rnrRr{Znormalized_itemsZ all_itemsir2Z normalized_iZnormalized_itemr/r/r0rls4        zValueItems._normalize_indexesFbaseoverride intersectcs||durS|sdurS|r&|r$SS|r;fddDfddD}n tfddD}i}|D]}|j|||d}|durd|||<qL|S)aHMerge a `base` item with an `override` item. Both `base` and `override` are converted to dictionaries if possible. Sets are converted to dictionaries with the sets entries as keys and Ellipsis as values. Each key-value pair existing in `base` is merged with `override`, while the rest of the key-value pairs are updated recursively with this function. Merging takes place based on the "union" of keys if `intersect` is set to `False` (default) and on the intersection of keys if `intersect` is set to `True`. Ncg|]}|vr|qSr/r/rYrU)rr/r0 z$ValueItems.merge..crr/r/rrr/r0rrcsg|]}|vr|qSr/r/rrr/r0rr)r)rrqr5rrr)rArrrZ merge_keysZmergedrUZ merged_itemr/)rrr0rs$    &zValueItems.mergecCsDt|tr |St|trt|d}|St|dd}td|)N.rz???z!Unexpected type of exclude value )r4rrrSfromkeysgetattrr?)rR class_namer/r/r0rks   zValueItems._coerce_itemscCs |dus ||r |S||Sr3)rqrk)rArir/r/r0r%s zValueItems._coerce_valuer2cCs|dup|duS)NT.r/r9r/r/r0rq+zValueItems.is_true_repr.ReprArgscCs d|jfgSr3rurnr/r/r0 __repr_args__/ zValueItems.__repr_args__N)rirrRrjr*rX)rprr*r+)rwrxr*ry)rRr#r{r|r*r})F)rrrrrr+r*r)rRrjr*r#)rirr*rr2rr*r+)r*r)__name__ __module__ __qualname____doc__ __slots__rortrvrzrl classmethodr staticmethodrkrrqrr/r/r/r0rfs"     %%   rfname get_valueCallable[[], T]cCdSr3r/rrr/r/r0LazyClassAttribute5src@s2eZdZdZddd Zedd d ZdddZdS)rzA descriptor exposing an attribute only accessible on a class (hidden from instances). The attribute is lazily computed and cached during the first access. rrHrCallable[[], Any]r*rXcCs||_||_dSr3r)rnrrr/r/r0ro?s zLazyClassAttribute.__init__rcCs|Sr3)rrr/r/r0riCszLazyClassAttribute.valueinstanceowner type[Any]cCs&|dur|jSt|jd|jd)Nz attribute of z is class-only)riAttributeErrorrr)rnrrr/r/r0__get__GszLazyClassAttribute.__get__N)rrHrrr*rX)r*r)rrrrr*rX)rrrrror rirr/r/r/r0r9s   Objobjc Cs~|tus|tur |S|j}|tvr|Sz|s&|tvr+|tur!|WS|WSWt |SWt |Sttt fy>Yt |Sw)zReturn type as is for immutable built-in types Use obj.copy() for built-in empty collections Use copy.deepcopy() for non-empty collections and unknown objects. ) rrrr'r(r6rQr? ValueError RuntimeErrorr )robj_typer/r/r0smart_deepcopyPs  rleft Iterable[Any]rightcCs*t||tdD] \}}||urdSqdS)aCheck that the items of `left` are the same objects as those in `right`. >>> a, b = object(), object() >>> all_identical([a, b, a], [a, b, a]) True >>> all_identical([a, b, [a]], [a, b, [a]]) # new list object, while "equal" is not "identical" False ) fillvalueFT)r _SENTINEL)rrZ left_itemZ right_itemr/r/r0 all_identicalhs  rabcCs|dur|S|S)zTReturn the first argument if it is not `None`, otherwise return the second argument.Nr/)rrr/r/r0get_first_not_nonewrrT)frozenc@s:eZdZUdZdZded<dd d Zerdd d ZdSdS)SafeGetItemProxyzWrapper redirecting `__getitem__` to `get` with a sentinel value as default This makes is safe to use in `operator.itemgetter` when some keys may be missing )wrappedzMapping[str, Any]rkeyrHr*rcCs|j|tSr3)rrrrrnrr/r/r0 __getitem__szSafeGetItemProxy.__getitem__r+cCs |j|Sr3)r __contains__rr/r/r0rrzSafeGetItemProxy.__contains__N)rrHr*r)rrHr*r+) rrrrr__annotations__rrrr/r/r/r0r|s  r_ModelTr&)bound_RTc@sLeZdZdZdddZedd d Zeedddddd Zddd ZdS)deprecated_instance_propertyaA decorator exposing the decorated class method as a property, with a warning on instance access. This decorator takes a class method defined on the `BaseModel` class and transforms it into an attribute. The attribute can be accessed on both the class and instances of the class. If accessed via an instance, a deprecation warning is emitted stating that instance access will be removed in V3. fgetCallable[[type[_ModelT]], _RT]r*rXcCs ||_dSr3)r)rnrr/r/r0ros z%deprecated_instance_property.__init__robjtype type[_ModelT]rcCrr3r/rnrrr/r/r0rsz$deprecated_instance_property.__get__zAccessing this attribute on the instance is deprecated, and will be removed in Pydantic V3. Instead, you should access this attribute from the model class.N)categoryrcCrr3r/rr/r/r0rs_ModelT | NonecCsL|durtjdkr |jjn|jjj}tjd|dtdd|j||S)N) zAccessing the zi attribute on the instance is deprecated. Instead, you should access this attribute from the model class.r%)r stacklevel) sys version_inforr__func__warningswarnrr)rnrr attr_namer/r/r0rs  )rrr*rX)rrXrrr*r)rrrrr*r)rrrrr*r)rrrrrorrrr/r/r/r0rs  r)r)r r*r+r)r;rr<r=r*r+)rArr<rr*r+)rArr*rE)rGrHr*r+)rNrOrPrOr*rO)rNrVrWrr*rX)r^r_r]r`r*ra)rrHrrr*r\)rrr*r)rrrrr*r+)rrrrr*r)gr __future__rZ _annotations dataclassesrJrrweakref collectionsrrrcollections.abcrrrr rrQr functoolsr inspectr itertoolsr typesrrrrrrtypingrrrrrZ pydantic_corerrZtyping_extensionsrrrZpydanticrr r!Z _import_utilsr"r|rHr#rr$mainr&floatcomplexr+bytesrBNoneTyperefNotImplementedrEllipsisr'r5r7r6r8rSr(r1r:r@rDrFrLrMrTr[r\reZRepresentationrfrrrobjectrrr dataclassrrrrr/r/r/r0s