o $6d-@sUdZddlmZddlZddlZddlZddlmZm Z m Z ddl m Z ddl mZddlmZmZmZmZmZmZddlmZmZdd lmZmZd d lmZmZejrhd Zd e d<dZ!d e d<ddl"m#Z#e$e%e&e'e(e)e*ej+eeeej,eee-j.e/j.hZ0de d<e1e2e3e4e5ee e hZ6de d<dOddZ7dPdd Z8dQd"d#Z9dRd%d&Z:dSd)d*Z;ed+Zed6Z?e'd7dVd=d>Z@Gd?d@d@ejAZBejrdWdCdDZCnGdEdDdDZCedFZDdXdHdIZEeFZGdYdMdNZHdS)ZzBucket 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)deepcopy) zip_longest)BuiltinFunctionTypeCodeType FunctionType GeneratorType LambdaType ModuleType)AnyTypeVar) TypeAlias TypeGuard)_repr _typing_extraz3typing.Mapping[int, Any] | typing.Mapping[str, Any]rMappingIntStrAnyz1typing.AbstractSet[int] | typing.AbstractSet[str]AbstractSetIntStr BaseModelzset[type[Any]]IMMUTABLE_NON_COLLECTIONS_TYPESBUILTIN_COLLECTIONSvrreturnboolcCst|ttttttfSN) isinstancelisttupleset frozensetr rrr&pC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\pydantic/_internal/_utils.py sequence_like>sr(oclass_or_tuple(type[Any] | tuple[type[Any], ...] | NonecCs"zt||WStyYdSwNF)r TypeError)r)r*r&r&r'lenient_isinstanceBs   r.clscCs:z t|to t||WStyt|tjrYdSwr,)r type issubclassr-rZ WithArgsTypes)r/r*r&r&r'lenient_issubclassIs  r2TypeGuard[type[BaseModel]]cCsddlm}t||o||uS)zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, unlike raw calls to lenient_issubclass. rr)mainrr2)r/rr&r&r'is_model_classRs r5 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)r6r&r&r'is_valid_identifier[sr;KeyTypemappingdict[KeyType, Any]updating_mappingscGsd|}|D])}|D]"\}}||vr*t||tr*t|tr*t|||||<q |||<q q|Sr)copyitemsr dict deep_update)r=r?Zupdated_mappingZupdating_mappingkrr&r&r'rCfs  rCdict[Any, Any]updateNonecKs|dd|DdS)NcSsi|] \}}|dur||qSrr&).0rDrr&r&r' rsz#update_not_none..)rFrA)r=rFr&r&r'update_not_noneqsrJT) name_factory input_listlist[T] | tuple[T, ...]rLtyping.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. root validator overridden in subclass). )appendindex)rMrLresultZ result_namesrZv_namer&r&r' unique_listxs   rTc@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_typevaluerrA$AbstractSetIntStr | MappingIntStrAnyrrGcCs2||}t|ttfr||t|}||_dSr) _coerce_itemsr r!r"_normalize_indexeslenrV)selfrXrAr&r&r'__init__s  zValueItems.__init__itemrcCs||j|S)zWCheck if item is fully excluded. :param item: key or index of a value )is_truerVgetr]r_r&r&r' is_excludedszValueItems.is_excludedcCs ||jvS)z`Check if value is contained in self._items. :param item: key or index of value rVrbr&r&r' 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)rVrar`)r]rfr_r&r&r' for_elements zValueItems.for_elementrv_lengthintdict[int | str, Any]c Cs i}d}|D]H\}}t|tjs(t|tjs(||s(td|d|j|dkr2||}qt|t s;td|dkrC||n|}| || |||<q|sU|S||rit |D]}| |dq^|St |D]}| |i}||s| ||||<qm|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.)rAr typingMapping AbstractSetr`r- __class__ _coerce_valuerkmergerarange setdefault) r]rArjZnormalized_itemsZ all_itemsirZ normalized_inormalized_itemr&r&r'r[s4 "       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&rHrD)ryr&r' z$ValueItems.merge..cr{r&r&r|rxr&r'r}r~csg|]}|vr|qSr&r&r|rr&r'r}r~)rz)rrr`r!rsra)r/rxryrzZ merge_keysmergedrDZ merged_itemr&)rxryr'rss$    &zValueItems.mergecCsHt|tjr |St|tjrt|d}|St|dd}td|)N.rqz???z!Unexpected type of exclude value )r rnrorprBfromkeysgetattrr-)rA class_namer&r&r'rZs   zValueItems._coerce_itemscCs |dus ||r |S||Sr)r`rZ)r/rXr&r&r'rrs zValueItems._coerce_valuercCs|dup|duS)NT.r&r%r&r&r'r` szValueItems.is_true_repr.ReprArgscCs d|jfgSrrd)r]r&r&r' __repr_args__s zValueItems.__repr_args__N)rXrrArYrrG)r_rrr)rfrgrrh)rArrjrkrrl)F)rxrryrrzrrr)rArYrr)rXrrrrrrr)rr)__name__ __module__ __qualname____doc__ __slots__r^rcrerir[ classmethodrs staticmethodrZrrr`rr&r&r&r'rUs"     %%   rUnamerXcCsdSrr&rrXr&r&r'ClassAttributesrc@s(eZdZdZdZdd d ZdddZdS)rz(Hide class attribute from its instances.rrr7rXrrrGcCs||_||_dSrr)r]rrXr&r&r'r^ s zClassAttribute.__init__instanceowner type[Any]cCs&|dur|jSt|jd|jd)Nz attribute of z is class-only)rXAttributeErrorrr)r]rrr&r&r'__get__$szClassAttribute.__get__N)rr7rXrrrG)rrrrrrG)rrrrrr^rr&r&r&r'rs  Objobjc Csj|j}|tvr |Sz|s|tvr!|tur|WS|WSWt|SWt|Stttfy4Yt|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. ) rqrrr"r@r- ValueError RuntimeErrorr)robj_typer&r&r'smart_deepcopy-s rlefttyping.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_EMPTY)rrZ left_itemZ right_itemr&r&r' all_identicalCs  rr)r)rr*r+rr)r/rr*rrr)r/rrr3)r6r7rr)r=r>r?r>rr>)r=rErFrrrG)rMrNrLrOrrP)rr7rXrKrrK)rrrr)rrrrrr)Ir __future__rZ _annotationsr9rnweakref collectionsrrrr@r itertoolsrtypesrr r r r r rrZtyping_extensionsrrrr TYPE_CHECKINGr__annotations__rr4rrkfloatcomplexr7rbytesr0NoneTyperefNotImplementedrqEllipsisrr!r#r"r$rBrr(r.r2r5r;r<rCrJrKrTZRepresentationrUrrrobjectrrr&r&r&r's|