o g4@s6UdZddlmZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZddlmZdd lmZmZmZmZmZmZdd lmZmZmZmZdd lm Z m!Z!d d l"m#Z#m$Z$d dl%m&Z&ej'rdZ(de)d<dZ*de)d<ddl+m,Z,e-e.e/e0e1e2e3e$j4eeeej5eee6j7e8j7hZ9de)d<e:e;ee e e hZ?de)d<d[ddZ@d\d!d"ZAd]d&d'ZBd^d)d*ZCd_d,d-ZDd`d0d1ZEed2ZFdad6d7ZGdbd;d<ZHed=ZIe0d>dcdDdEZJGdFdGdGe#jKZLej'rdddKdLZMnGdMdLdLZMedNZNdedPdQZOePZQdfdUdVZRejSdWdXGdYdZdZZTdS)gzBucket 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)cached_property) Parameter) zip_longest)BuiltinFunctionTypeCodeType FunctionType GeneratorType LambdaType ModuleType)AnyCallableMappingTypeVar) TypeAlias TypeGuard)_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_COLLECTIONSparamrreturnboolcCs|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 ``` )kindrPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORD)r r&P/var/www/visachat/venv/lib/python3.10/site-packages/pydantic/_internal/_utils.pycan_be_positionalCsr(vrcCst|ttttttfSN) isinstancelisttupleset frozensetr rr)r&r&r' sequence_likeVsr1oclass_or_tuple(type[Any] | tuple[type[Any], ...] | NonecCs"zt||WStyYdSwNF)r+ TypeError)r2r3r&r&r'lenient_isinstanceZs   r7clscCs:z t|to t||WStyt|tjrYdSwr5)r+type issubclassr6r WithArgsTypes)r8r3r&r&r'lenient_issubclassas  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<)r8rr&r&r'is_model_classjsr> 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)r?r&r&r'is_valid_identifierssrDKeyTypemappingdict[KeyType, Any]updating_mappingscGsd|}|D])}|D]"\}}||vr*t||tr*t|tr*t|||||<q |||<q q|Sr*)copyitemsr+dict deep_update)rFrHupdated_mappingupdating_mappingkr)r&r&r'rL~s  rLdict[Any, Any]updateNonecKs|dd|DdS)NcSsi|] \}}|dur||qSr*r&).0rOr)r&r&r' sz#update_not_none..)rQrJ)rFrQr&r&r'update_not_nonesrUT) name_factory input_listlist[T] | tuple[T, ...]rWtyping.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)rXrWresult result_namesr)v_namer&r&r' unique_lists   rac@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_typevaluerrJ$AbstractSetIntStr | MappingIntStrAnyr!rRcCs2||}t|ttfr||t|}||_dSr*) _coerce_itemsr+r,r-_normalize_indexeslenrc)selfrerJr&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_truercgetrjrlr&r&r' is_excludedszValueItems.is_excludedcCs ||jvS)z`Check if value is contained in self._items. :param item: key or index of value rcror&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)rcrnrm)rjrsrlr&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.)rJr+typingr AbstractSetrmr6 __class__ _coerce_valuerxmergernrange setdefault) rjrJrwnormalized_items all_itemsir) normalized_inormalized_itemr&r&r'rhs4 "       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&rSrO)rr&r' z$ValueItems.merge..crr&r&rrr&r'rrcsg|]}|vr|qSr&r&rrr&r'r r)r)r~rmr,rrn)r8rrr merge_keysmergedrO merged_itemr&)rrr'rs$    &zValueItems.mergecCsHt|tjr |St|tjrt|d}|St|dd}td|)N.r}z???z!Unexpected type of exclude value )r+r{rr|rKfromkeysgetattrr6)rJ class_namer&r&r'rgs   zValueItems._coerce_itemscCs |dus ||r |S||Sr*)rmrg)r8rer&r&r'r~s zValueItems._coerce_valuer)cCs|dup|duS)NT.r&r0r&r&r'rm$szValueItems.is_true_repr.ReprArgscCs d|jfgSr*rqrjr&r&r' __repr_args__( zValueItems.__repr_args__N)rerrJrfr!rR)rlrr!r")rsrtr!ru)rJrrwrxr!ry)F)rrrrrr"r!r)rJrfr!r)rerr!rr)rr!r")r!r)__name__ __module__ __qualname____doc__ __slots__rkrprrrvrh classmethodr staticmethodrgr~rmrr&r&r&r'rbs"     %%   rbname get_valueCallable[[], T]cCsdSr*r&rrr&r&r'LazyClassAttribute.src@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. rr@rCallable[[], Any]r!rRcCs||_||_dSr*r)rjrrr&r&r'rk8s zLazyClassAttribute.__init__rcCs|Sr*)rrr&r&r're<szLazyClassAttribute.valueinstanceowner type[Any]cCs&|dur|jSt|jd|jd)Nz attribute of z is class-only)reAttributeErrorrr)rjrrr&r&r'__get__@szLazyClassAttribute.__get__N)rr@rrr!rR)r!r)rrrrr!rR)rrrrrkrrerr&r&r&r'r2s   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. ) r}rrr-rIr6 ValueError RuntimeErrorr)robj_typer&r&r'smart_deepcopyIs 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_identical_s  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]rkeyr@r!rcCs|j|tSr*)rrnrrjrr&r&r' __getitem__{szSafeGetItemProxy.__getitem__r"cCs |j|Sr*)r __contains__rr&r&r'rrzSafeGetItemProxy.__contains__N)rr@r!r)rr@r!r") rrrrr__annotations__rr{ TYPE_CHECKINGrr&r&r&r'rns  r)r rr!r"r)r2rr3r4r!r")r8rr3rr!r")r8rr!r=)r?r@r!r")rFrGrHrGr!rG)rFrPrQrr!rR)rXrYrWrZr!r[)rr@rrr!rV)rrr!r)rrrrr!r")Ur __future__r _annotations dataclassesrBr{weakref collectionsrrrrIr functoolsrinspectr itertoolsr typesr r r r rrrrrrtyping_extensionsrrrr _import_utilsrrrrrmainrrxfloatcomplexr@r"bytesr9NoneTyperefNotImplementedr}Ellipsisrr,r.r-r/rKrr(r1r7r<r>rDrErLrUrVraRepresentationrbrrrobjectrr dataclassrr&r&r&r's