Lqj;tUdZddlmZddlZddlZddlZddlZddlZddl 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,jxeeee jzeee>j~e@j~hZAde1d<eBeCeDeEeFe e e hZGde1d<d9dZHd:dZId;dZJdd ZMe"d!ZNd?d"ZOd@d#ZPe"d$ZQe8d% dAd&ZRGd'd(e+jZTej^rdBd)ZUn Gd*d+ZUe"d,ZVdCd-ZWeXZYdDd.ZZejd/0Gd1d2Z\e"d3d45Z]e"d6Z^Gd7d8e!e]e^fZ_y)EzBucket 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_COLLECTIONScZ|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)params e/var/www/html/ai-menu-system/python-ai/venv/lib/python3.12/site-packages/pydantic/_internal/_utils.pycan_be_positionalr+Hs$ ::)33Y5T5TU UUc Vt|ttttt t fSN) isinstancelisttupleset frozensetrrvs r* sequence_liker6[s a$sI}eL MMr,c: t||S#t$rYywxYwNF)r/ TypeError)oclass_or_tuples r*lenient_isinstancer<_s&!^,, s  c t|txr t||S#t$rt|tj rYywxYwr8)r/type issubclassr9r WithArgsTypes)clsr;s r*lenient_issubclassrBfsE#t$HC)HH  c=66 7 s #AAc:t}t||xr||uS)zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, unlike raw calls to lenient_issubclass. )rrB)rAr"s r*is_model_classrDos#)*I c9 - F#Y2FFr,cR|jxrtj| 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) identifiers r*is_valid_identifierrJxs&  " " $ JW->->z-J)JJr,KeyTypec|j}|D]Y}|jD]D\}}||vr6t||tr#t|trt |||||<@|||<F[|Sr.)copyitemsr/dict deep_update)mappingupdating_mappingsupdated_mappingupdating_mappingkr5s r*rPrPsllnO-'$**, 'DAqO# ?13Et(LQ[\]_cQd%01CQ%G"%&"  '' r,c ||j|jDcic] \}}| || c}}ycc}}wr.)updaterN)rQrWrUr5s r*update_not_nonerXs. NNV\\^ETQq}AqDEFEs 8 8 T) name_factorycg}g}|D]E}||}||vr#|j||j|2|||j|<G|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) input_listrZresult result_namesr5v_names r* unique_listrbsdF L 3a  %    ' MM! 12F<%%f- . 3 Mr,ceZdZdZdZddZddZddZddZddZ e dddZ e dd Z e dd Ze dd Zdd Zy ) ValueItemszOClass for more convenient calculation of excluded or included fields on values.)_items_typec|j|}t|ttfr|j |t |}||_yr.) _coerce_itemsr/r0r1_normalize_indexeslenre)selfvaluerNs r*__init__zValueItems.__init__s=""5) edE] +++E3u:>E(- r,cV|j|jj|S)zWCheck if item is fully excluded. :param item: key or index of a value )is_trueregetrkitems r* is_excludedzValueItems.is_excludeds ||DKKOOD122r,c||jvS)z`Check if value is contained in self._items. :param item: key or index of value rerqs r* is_includedzValueItems.is_includeds t{{""r,cb|jj|}|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)rerpro)rkerrs r* for_elementzValueItems.for_elements,{{q!<<-t747r,ci}d}|jD]\}}t|tjsFt|tjs,|j |st d|d|j|dk(r|j|}}t|ts t d|dkr||zn|}|j||j|||<|s|S|j |r$t|D]}|j|d|St|D];}|j|i}|j |r'|j||||<=|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 AbstractSetror9 __class__ _coerce_valueintmergerprange setdefault) rkrNv_lengthnormalized_items all_itemsir5 normalized_inormalized_items r*rizValueItems._normalize_indexessv24 KKM _DAqq&..1Z6CUCU5VZ^ZfZfghZi"NqcQSTUT_T_S` abbI~ ..q1 a%A,-q58a|Scc}wcc}wcc}w)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`. ) intersect)rror0rrp)rAbaseoverriderrU merge_keysmerged merged_items r*rzValueItems.merges $$X.  &  K ;;t  O ;;x $4 2( 2 %);Q(]!;(>`QVW[_V_q>``Jd(&LQatmq&LLJ') (A))DHHQKaI)VK&'q  (  <>`&Ls$ C'#C'- C,7C, C1C1ct|tjr |St|tjrtj |d}|St |dd}td|)N.r~z???z!Unexpected type of exclude value )r/r|rr}rOfromkeysgetattrr9)rN class_names r*rhzValueItems._coerce_itemssf eV^^ ,   v11 2MM%-E ! U;J? |LM Mr,cN||j|r|S|j|Sr.)rorh)rArls r*rzValueItems._coerce_value#s( =CKK.L  ''r,c|duxs|duS)NT.r4s r*rozValueItems.is_true)sDy$AH$r,c d|jfgSr.rurks r* __repr_args__zValueItems.__repr_args__-st{{#$$r,N)rlrrN$AbstractSetIntStr | MappingIntStrAnyreturnNone)rrrrbool)rxz int | strrz+AbstractSetIntStr | MappingIntStrAny | None)rNrrrrzdict[int | str, Any])F)rrrrrrrr)rNrrr)rlrrrr5rrr)rz_repr.ReprArgs)__name__ __module__ __qualname____doc__ __slots__rmrsrvryri classmethodr staticmethodrhrrorrr,r*rdrdszY#I.3#8# J##J(( %%%r,rdcyr.rname get_values r*LazyClassAttributer3sr,c2eZdZdZddZeddZddZy) rzA descriptor exposing an attribute only accessible on a class (hidden from instances). The attribute is lazily computed and cached during the first access. c ||_||_yr.r)rkrrs r*rmzLazyClassAttribute.__init__=sDI&DNr,c"|jSr.)rrs r*rlzLazyClassAttribute.valueAs>># #r,ch| |jSt|jd|jd)Nz attribute of z is class-only)rlAttributeErrorrr)rkinstanceowners r*__get__zLazyClassAttribute.__get__Es4zz! DII=u~~>PP^!_` `r,N)rstrrzCallable[[], Any]rr)rr)rrrz type[Any]rr)rrrrrmr rlrrr,r*rr7s&  '  $  $ ar,rObjc|j}|tvr|S |s"|tvr|tur|S|j St|S#t t tf$r Yt|SwxYw)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~r#r$r1rMr9 ValueError RuntimeErrorr)objobj_types r*smart_deepcopyrNst }}H22  x#66"e+3 ; ; C= z< 0  C=  sAAA('A(cDt||tD] \}}||us yy)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)leftright left_item right_items r* all_identicalrds1"-T5I!N : J & r,T)frozencJeZdZUdZdZded<ddZejrd dZ yy) 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]rcB|jj|tSr.)rrprrkkeys r* __getitem__zSafeGetItemProxy.__getitem__s||Y//r,c8|jj|Sr.)r __contains__rs r*rzSafeGetItemProxy.__contains__s<<,,S1 1r,N)rrrr)rrrr) rrrrr__annotations__rr| TYPE_CHECKINGrrr,r*rrss.I 0 2r,r_ModelTr")bound_RTc^eZdZdZd dZed dZeeddd dZd dZy) 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. c||_yr.)fget)rkrs r*rmz%deprecated_instance_property.__init__s  r,cyr.rrkrobjtypes r*rz$deprecated_instance_property.__get__sFIr,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)categorycyr.rrs r*rz$deprecated_instance_property.__get__s JMr,c|itjdk\r|jjn|jjj}t j d|dtd|jj||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)rkrr attr_names r*rz$deprecated_instance_property.__get__sy  .1.>.>'.I **tyyOaOaOjOjI MM  .RR3   4tyy  7355r,)rzCallable[[type[_ModelT]], _RT]rr)rrr type[_ModelT]rr)rrrrrr)rz_ModelT | Nonerrrr)rrrrrmrrrrr,r*rrsKII  J M  M 6r,r)r)r rrr)r:rr;z(type[Any] | tuple[type[Any], ...] | Nonerr)rArr;rrr)rArrzTypeGuard[type[BaseModel]])rIrrr)rQdict[KeyType, Any]rRrrr)rQzdict[Any, Any]rWrrr)r^zlist[T] | tuple[T, ...]rZztyping.Callable[[T], str]rzlist[T])rrrzCallable[[], T]rrY)rrrr)rtyping.Iterable[Any]rrrr)`r __future__r _annotations dataclassesrGrr|rweakref collectionsrrrcollections.abcrrMr functoolsr inspectr itertoolsr typesr r rrrrrrrrrtyping_extensionsrrrpydanticrrr _import_utilsrrrrr mainr"rfloatcomplexrrbytesr>NoneTyperefNotImplementedr~Ellipsisr#r0r2r1r3rOr$r+r6r<rBrDrJrKrPrXrYrbRepresentationrdrrrobjectrr dataclassrrrrrr,r*rs 3 77#%!dd<<>>/"3 "WiW#VyV     KK  '30     '^ V&NGK ) G CL /2', ,C%%%C%L Kaa(en& H  d#22$22 ); / en677C<#86r,