RPf|1UdZddlmZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZmZmZmZmZmZddlmZmZmZdd lmZmZd d lmZmZej@rd Z!d e"d<dZ#d e"d<ddl$m%Z%e&e'e(e)e*e+e,ejZeeeej\eee/j`e1j`hZ2de"d<e3e4e5e6e7e e e hZ8de"d<d-dZ9d.dZ:d/dZ;d0dZd2dZ?d3dZ@edZAe)d d4d ZBGd!d"ejZDej@rd5d#ZEn Gd$d%ZEed&ZFd6d'ZGeHZId7d(ZJejd)*Gd+d,ZLy)8zBucket 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)AnyMappingTypeVar) 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_COLLECTIONSc Vt|ttttt t fSN) isinstancelisttupleset frozensetr rvs S/var/www/fastapitest/venv/lib/python3.12/site-packages/pydantic/_internal/_utils.py sequence_liker(?s a$sI}eL MMc: t||S#t$rYywxYwNF)r TypeError)oclass_or_tuples r'lenient_isinstancer/Cs&!^,, s  c t|txr t||S#t$rt|tj rYywxYwr+)r type issubclassr,r WithArgsTypes)clsr.s r'lenient_issubclassr5JsE#t$HC)HH  c=66 7 s #AAc2ddlm}t||xr||uS)zReturns true if cls is a _proper_ subclass of BaseModel, and provides proper type-checking, unlike raw calls to lenient_issubclass. rr)mainrr5)r4rs r'is_model_classr8Ss! 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_identifierr>\s&  " " $ JW->->z-J)JJr)KeyTypec|j}|D]Y}|jD]D\}}||vr6t||tr#t|trt |||||<@|||<F[|Sr)copyitemsr dict deep_update)mappingupdating_mappingsupdated_mappingupdating_mappingkr&s r'rDrDgsllnO-'$**, 'DAqO# ?13Et(LQ[\]_cQd%01CQ%G"%&"  '' r)c ||j|jDcic] \}}| || c}}ycc}}wr)updaterB)rErKrIr&s r'update_not_nonerLrs. 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_listrNresult result_namesr&v_names r' unique_listrVysdF 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 r!r"_normalize_indexeslenrY)selfvaluerBs 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_truerYgetr_items r' is_excludedzValueItems.is_excludeds ||DKKOOD122r)c||jvS)z`Check if value is contained in self._items. :param item: key or index of value rYres 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)rYrdrc)r_erfs 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.)rBr typingr AbstractSetrcr, __class__ _coerce_valueintmergerdrange setdefault) r_rBv_lengthnormalized_items all_itemsir& normalized_inormalized_items r'r]zValueItems._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)rsrcr!rurd)r4baseoverriderrI merge_keysmerged merged_items r'ruzValueItems.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.rrz???z!Unexpected type of exclude value )r rprrqrCfromkeysgetattrr,)rB class_names r'r\zValueItems._coerce_itemssf eV^^ ,   v11 2MM%-E ! U;J? |LM Mr)cN||j|r|S|j|Sr)rcr\)r4r`s r'rszValueItems._coerce_values( =CKK.L  ''r)c|duxs|duS)NT.r%s r'rczValueItems.is_true sDy$AH$r)c d|jfgSrri)r_s r' __repr_args__zValueItems.__repr_args__st{{#$$r)N)r`rrB$AbstractSetIntStr | MappingIntStrAnyreturnNone)rfrrbool)rlz int | strrz+AbstractSetIntStr | MappingIntStrAny | None)rBrrxrtrzdict[int | str, Any])F)rrrrrrrr)rBrrr)r`rrrr&rrr)rz_repr.ReprArgs)__name__ __module__ __qualname____doc__ __slots__rargrjrmr] classmethodru staticmethodr\rsrcrrr)r'rXrXszY#I.3#8# J##J(( %%%r)rXcyrrnamer`s r'ClassAttributers r)c$eZdZdZdZddZddZy)rz(Hide class attribute from its instances.rc ||_||_yrr)r_rr`s r'razClassAttribute.__init__!sDIDJr)ch| |jSt|jd|jd)Nz attribute of z is class-only)r`AttributeErrorrr)r_instanceowners r'__get__zClassAttribute.__get__%s4zz! DII=u~~>PP^!_` `r)N)rstrr`rrr)rrrz type[Any]rr)rrrrrrarrr)r'rrs6#   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. ) rrrrr"rAr, ValueError RuntimeErrorr)objobj_types r'smart_deepcopyr.st }}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)rrdrr_keys r' __getitem__zSafeGetItemProxy.__getitem__`s||Y//r)c8|jj|Sr)r __contains__rs r'rzSafeGetItemProxy.__contains__is<<,,S1 1r)N)rrrr)rrrr) rrrrr__annotations__rrp TYPE_CHECKINGrrr)r'rrSs.I 0 2r)rr)r-rr.z(type[Any] | tuple[type[Any], ...] | Nonerr)r4rr.rrr)r4rrzTypeGuard[type[BaseModel]])r=rrr)rEdict[KeyType, Any]rFrrr)rEzdict[Any, Any]rKrrr)rRzlist[T] | tuple[T, ...]rNztyping.Callable[[T], str]rzlist[T])rrr`rMrrM)rrrr)rtyping.Iterable[Any]rrrr)Mr __future__r _annotations dataclassesr;rpweakref collectionsrrrrAr itertoolsrtypesr r r r r rrrrtyping_extensionsrrrrrrrrr7rrtfloatcomplexrrbytesr1NoneTyperefNotImplementedrrEllipsisrr!r#r"r$rCrr(r/r5r8r>r?rDrLrMrVRepresentationrXrrrobjectrr dataclassrrr)r'rs3 77!dd((2" "WiW#VyV     KK  '30     '^ NGK ) G CL /2', ,C%%%C%L  a aen& H  d#22$2r)