o ~j6h;@sUdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z ddlmZddlmZddlmZddlmZdd lmZdd lmZmZmZmZmZmZdd lmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'dd l(m)Z)ddl*m+Z+m,Z,ddl-m.Z.ej/rdZ0de1d<dZ2de1d<ddl3m4Z4e5e6e7e8e9e:e;e,jj?e@j?hZAde1d<eBeCeDeEeFe e e hZGde1d<dcdd ZHddd#d$ZIded(d)ZJdfd+d,ZKdgd.d/ZLdhd2d3ZMe"d4ZNdid8d9ZOdjd=d>ZPe"d?ZQe8d@dkdFdGZRGdHdIdIe+jSZTej/r dldMdNZUnGdOdNdNZUe"dPZVdmdRdSZWeXZYdndWdXZZej[dYdZGd[d\d\Z\e"d]d^d_Z]e"d`Z^Gdadbdbe!e]e^fZ_dS)ozBucket 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)Mapping)deepcopy)cached_property) Parameter) zip_longest)BuiltinFunctionTypeCodeType FunctionType GeneratorType LambdaType ModuleType)AnyCallableGenericTypeVaroverload) TypeAlias TypeGuard deprecated)PydanticDeprecatedSince211)_repr _typing_extra)import_cached_base_modelz3typing.Mapping[int, Any] | typing.Mapping[str, Any]rMappingIntStrAnyz1typing.AbstractSet[int] | typing.AbstractSet[str]AbstractSetIntStr) 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*h/var/www/html/chefvision.cloud.itp360.com/venv/lib/python3.10/site-packages/pydantic/_internal/_utils.pycan_be_positionalHsr,vrcCst|ttttttfSN) isinstancelisttupleset frozensetrrr-r*r*r+ sequence_like[sr5oclass_or_tuple(type[Any] | tuple[type[Any], ...] | NonecCs"zt||WStyYdSwNF)r/ TypeError)r6r7r*r*r+lenient_isinstance_s   r;clscCs:z t|to t||WStyt|tjrYdSwr9)r/type issubclassr:r WithArgsTypes)r<r7r*r*r+lenient_issubclassfs  r@TypeGuard[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. )rr@)r<r!r*r*r+is_model_classosrB 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)rCr*r*r+is_valid_identifierxsrHKeyTypemappingdict[KeyType, Any]updating_mappingscGsd|}|D])}|D]"\}}||vr*t||tr*t|tr*t|||||<q |||<q q|Sr.)copyitemsr/dict deep_update)rJrLupdated_mappingupdating_mappingkr-r*r*r+rPs  rPdict[Any, Any]updateNonecKs|dd|DdS)NcSsi|] \}}|dur||qSr.r*).0rSr-r*r*r+ sz#update_not_none..)rUrN)rJrUr*r*r+update_not_nonesrYT) name_factory input_listlist[T] | tuple[T, ...]r[typing.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[result result_namesr-v_namer*r*r+ 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_typevaluerrN$AbstractSetIntStr | MappingIntStrAnyr%rVcCs2||}t|ttfr||t|}||_dSr.) _coerce_itemsr/r0r1_normalize_indexeslenrg)selfrirNr*r*r+__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*r+ is_excludedszValueItems.is_excludedcCs ||jvS)z`Check if value is contained in self._items. :param item: key or index of value rgrsr*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)rgrrrq)rnrwrpr*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.)rNr/typingr AbstractSetrqr: __class__ _coerce_valuer|mergerrrange setdefault) rnrNr{normalized_items all_itemsir- normalized_inormalized_itemr*r*r+rls4 "       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*rWrS)rr*r+ z$ValueItems.merge..crr*r*rrr*r+r rcsg|]}|vr|qSr*r*rrr*r+rr)r)rrqr0rrr)r<rrr merge_keysmergedrS merged_itemr*)rrr+rs$    &zValueItems.mergecCsHt|tjr |St|tjrt|d}|St|dd}td|)N.rz???z!Unexpected type of exclude value )r/rrrrOfromkeysgetattrr:)rN class_namer*r*r+rks   zValueItems._coerce_itemscCs |dus ||r |S||Sr.)rqrk)r<rir*r*r+r#s zValueItems._coerce_valuer-cCs|dup|duS)NT.r*r4r*r*r+rq)szValueItems.is_true_repr.ReprArgscCs d|jfgSr.rurnr*r*r+ __repr_args__- zValueItems.__repr_args__N)rirrNrjr%rV)rprr%r&)rwrxr%ry)rNrr{r|r%r})F)rrrrrr&r%r)rNrjr%r)rirr%rr-rr%r&)r%r)__name__ __module__ __qualname____doc__ __slots__rortrvrzrl classmethodr staticmethodrkrrqrr*r*r*r+rfs"     %%   rfname get_valueCallable[[], T]cCdSr.r*rrr*r*r+LazyClassAttribute3src@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. rrDrCallable[[], Any]r%rVcCs||_||_dSr.r)rnrrr*r*r+ro=s zLazyClassAttribute.__init__rcCs|Sr.)rrr*r*r+riAszLazyClassAttribute.valueinstanceowner type[Any]cCs&|dur|jSt|jd|jd)Nz attribute of z is class-only)riAttributeErrorrr)rnrrr*r*r+__get__EszLazyClassAttribute.__get__N)rrDrrr%rV)r%r)rrrrr%rV)rrrrrorrirr*r*r*r+r7s   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. ) rr"r#r1rMr: ValueError RuntimeErrorr)robj_typer*r*r+smart_deepcopyNs 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 _SENTINEL)rr left_item right_itemr*r*r+ all_identicalds  rT)frozenc@s<eZdZUdZdZded<dd d Zejrdd d Z dSdS)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]rkeyrDr%rcCs|j|tSr.)rrrrrnrr*r*r+ __getitem__szSafeGetItemProxy.__getitem__r&cCs |j|Sr.)r __contains__rr*r*r+rrzSafeGetItemProxy.__contains__N)rrDr%r)rrDr%r&) rrrrr__annotations__rr TYPE_CHECKINGrr*r*r*r+rss  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%rVcCs ||_dSr.)r)rnrr*r*r+ros z%deprecated_instance_property.__init__robjtype type[_ModelT]rcCrr.r*rnrrr*r*r+rsz$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)categoryrcCrr.r*rr*r*r+rs_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*r+rs )rrr%rV)rrVrrr%r)rrrrr%r)rrrrr%r)rrrrrorrrr*r*r*r+rs  r)r$r r%r&r)r6rr7r8r%r&)r<rr7rr%r&)r<rr%rA)rCrDr%r&)rJrKrLrKr%rK)rJrTrUrr%rV)r\r]r[r^r%r_)rrDrrr%rZ)rrr%r)rrrrr%r&)`r __future__r _annotations dataclassesrFrrrweakref collectionsrrrcollections.abcrrMr functoolsrinspectr itertoolsr typesr r r rrrrrrrrtyping_extensionsrrrpydanticrrr _import_utilsrrrrrmainr!r|floatcomplexrDr&bytesr=NoneTyperefNotImplementedrEllipsisr"r0r2r1r3rOr#r,r5r;r@rBrHrIrPrYrZreRepresentationrfrrrobjectrr dataclassrrrrr*r*r*r+s