a h;@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/r6dZ0de1d<dZ2de1d<ddl3m4Z4e5e6e7e8e9e:e;e,jj?e@j?hZAde1d<eBeCeDeEeFe e e hZGde1d<dddddZHd dd!d"d#ZId d$dd%d&d'ZJd d dd(d)d*ZKd d+d,d-d.ZLd/dd0d1d2ZMe"d3ZNd4d4d4d5d6d7ZOd8d d9d:d;d<ZPe"d=ZQe8d>d?d@dAdBdCdDZRGdEdFdFe+jSZTej/rdd/dGd=dHdIdJZUnGdKdJdJZUe"dLZVdLdLdMdNdOZWeXZYdPdPddQdRdSZZej[dTdUGdVdWdWZ\e"dXdYdZZ]e"d[Z^Gd\d]d]e!e]e^fZ_dS)^zBucket 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_COLLECTIONSr bool)paramreturncCs|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*U/var/www/html/assistant/venv/lib/python3.9/site-packages/pydantic/_internal/_utils.pycan_be_positionalHsr,rvr&cCst|ttttttfSN) isinstancelisttupleset frozensetrrr.r*r*r+ sequence_like[sr6z(type[Any] | tuple[type[Any], ...] | None)oclass_or_tupler&cCs&z t||WSty YdS0dSNF)r0 TypeError)r7r8r*r*r+lenient_isinstance_s  r;)clsr8r&cCsBzt|tot||WSty<t|tjr6YdSYn0dSr9)r0type issubclassr:rZ WithArgsTypes)r<r8r*r*r+lenient_issubclassfs   r?zTypeGuard[type[BaseModel]])r<r&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_classosr@str) identifierr&cCs|ot| 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)rBr*r*r+is_valid_identifierxsrFKeyTypezdict[KeyType, Any])mappingupdating_mappingsr&cGsd|}|D]R}|D]D\}}||vrTt||trTt|trTt|||||<q|||<qq |Sr/)copyitemsr0dict deep_update)rHrIZupdated_mappingZupdating_mappingkr.r*r*r+rMs  rMzdict[Any, Any]None)rHupdater&cKs|dd|DdS)NcSsi|]\}}|dur||qSr/r*).0rNr.r*r*r+ z#update_not_none..)rPrK)rHrPr*r*r+update_not_nonesrTT) name_factoryzlist[T] | tuple[T, ...]ztyping.Callable[[T], str]zlist[T]) input_listrVr&cCsJg}g}|D]8}||}||vr6||||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)rWrVresultZ result_namesr.Zv_namer*r*r+ unique_lists   r[c@seZdZdZdZddddddZdd d d d Zdd d d dZdddddZddddddZ e d,ddd ddddZ e ddddd Z e ddd!d"d#Ze dd d$d%d&Zd'd(d)d*Zd+S)- ValueItemszOClass for more convenient calculation of excluded or included fields on values.)_items_typerz$AbstractSetIntStr | MappingIntStrAnyrO)valuerKr&cCs2||}t|ttfr(||t|}||_dSr/) _coerce_itemsr0r1r2_normalize_indexeslenr])selfr_rKr*r*r+__init__s zValueItems.__init__r$)itemr&cCs||j|S)zWCheck if item is fully excluded. :param item: key or index of a value )is_truer]getrcrer*r*r+ is_excludedszValueItems.is_excludedcCs ||jvS)z`Check if value is contained in self._items. :param item: key or index of value r]rhr*r*r+ is_includedszValueItems.is_includedz int | strz+AbstractSetIntStr | MappingIntStrAny | None)er&cCs|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)r]rgrf)rcrlrer*r*r+ for_elements zValueItems.for_elementrintzdict[int | str, Any])rKv_lengthr&c Cs i}d}|D]\}}t|tjsPt|tjsP||sPtd|d|j|dkrd||}qt|t svtd|dkr||n|}| || |||<q|s|S||rt |D]}| |dq|St |D]*}| |i}||s| ||||<q|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.)rKr0typingr AbstractSetrfr: __class__ _coerce_valuernmergergrange setdefault) rcrKroZnormalized_itemsZ all_itemsir.Z normalized_inormalized_itemr*r*r+ras2 "       zValueItems._normalize_indexesF)baseoverride intersectr&cs||dur S|s2dur6S|rL|rHSS|rvfddDfddD}ntfddD}i}|D]0}|j|||d}|dur|||<q|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`. Ncsg|]}|vr|qSr*r*rQrN)r{r*r+ rSz$ValueItems.merge..csg|]}|vr|qSr*r*r}rzr*r+r~ rScsg|]}|vr|qSr*r*r}rr*r+r~rS)r|)rtrfr1rurg)r<rzr{r|Z merge_keysmergedrNZ merged_itemr*)rzr{r+rus"    & zValueItems.merge)rKr&cCsFt|tjrn4t|tjr(t|d}nt|dd}td||S)N.rsz???z!Unexpected type of exclude value )r0rqrrrrLfromkeysgetattrr:)rK class_namer*r*r+r`s   zValueItems._coerce_items)r_r&cCs |dus||r|S||Sr/)rfr`)r<r_r*r*r+rt#szValueItems._coerce_valuer-cCs|dup|duS)NT.r*r5r*r*r+rf)szValueItems.is_truez_repr.ReprArgsr&cCs d|jfgSr/rjrcr*r*r+ __repr_args__-szValueItems.__repr_args__N)F)__name__ __module__ __qualname____doc__ __slots__rdrirkrmra classmethodru staticmethodr`rtrfrr*r*r*r+r\s %% r\zCallable[[], T]name get_valuer&cCsdSr/r*rrr*r*r+LazyClassAttribute3rSrc@sFeZdZdZddddddZedd d d Zdd dd ddZdS)rzA descriptor exposing an attribute only accessible on a class (hidden from instances). The attribute is lazily computed and cached during the first access. rAzCallable[[], Any]rOrcCs||_||_dSr/r)rcrrr*r*r+rd=szLazyClassAttribute.__init__rrcCs|Sr/)rrr*r*r+r_AszLazyClassAttribute.valuez type[Any])instanceownerr&cCs*|dur|jSt|jd|jddS)Nz attribute of z is class-only)r_AttributeErrorrr)rcrrr*r*r+__get__EszLazyClassAttribute.__get__N)rrrrrdrr_rr*r*r*r+r7s Obj)objr&c CsZ|j}|tvr|Sz&|s6|tvr6|tur,|n|WSWntttfyPYn0t|S)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. ) rsr"r#r2rJr: ValueError RuntimeErrorr)rZobj_typer*r*r+smart_deepcopyNs rztyping.Iterable[Any])leftrightr&cCs*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*r+ all_identicalds rT)frozenc@sDeZdZUdZdZded<ddddd Zejr@dd dd d Z d S)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]rrAr)keyr&cCs|j|tSr/)rrgrrcrr*r*r+ __getitem__szSafeGetItemProxy.__getitem__r$cCs |j|Sr/)r __contains__rr*r*r+rszSafeGetItemProxy.__contains__N) rrrrr__annotations__rrq TYPE_CHECKINGrr*r*r*r+rss r_ModelTr!)bound_RTc@sjeZdZdZdddddZedddd d d Zeed d ddddd dd Zdddd dd Zd S)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. zCallable[[type[_ModelT]], _RT]rO)fgetr&cCs ||_dSr/)r)rcrr*r*r+rdsz%deprecated_instance_property.__init__z type[_ModelT]r)robjtyper&cCsdSr/r*rcrrr*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)categoryrcCsdSr/r*rr*r*r+rsz_ModelT | NonecCsL|durs