j1UdZddlmZddlZddlZddlZddlZddlm Z m Z m Z ddl m Z ddlmZddlmZmZmZmZmZmZddlmZmZmZdd lmZmZd d lmZmZd d l m!Z!ejDrd Z#de$d<dZ%de$d<ddl&m'Z'e(e)e*e+e,e-e.ej^eeeej`eee1jde3jdhZ4de$d<e5e6e7e8e9e e e hZ:de$d<d.dZ;d/dZd2dZ?edZ@d3dZAd4dZBedZCe+d  d5d!ZDGd"d#ejZFejDrd6d$ZGn Gd%d&ZGed'ZHd7d(ZIeJZKd8d)ZLejd*+Gd,d-ZNy)9zBucket 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_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_COLLECTIONSc Vt|ttttt t fSN) isinstancelisttupleset frozensetr rvs f/home/oem/CyberBrain26-unified/dev-env/.venv/lib/python3.12/site-packages/pydantic/_internal/_utils.py sequence_liker(As a$sI}eL MMc: t||S#t$rYywxYwNF)r TypeError)oclass_or_tuples r'lenient_isinstancer/Es&!^,, s  c t|txr t||S#t$rt|tj rYywxYwr+)r type issubclassr,r WithArgsTypes)clsr.s r'lenient_issubclassr5LsE#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. )rr5)r4rs r'is_model_classr7Us#)*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_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'rCrCisllnO-'$**, 'DAqO# ?13Et(LQ[\]_cQd%01CQ%G"%&"  '' r)c ||j|jDcic] \}}| || c}}ycc}}wr)updaterA)rDrJrHr&s r'update_not_nonerKts. 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_listrMresult result_namesr&v_names r' unique_listrU{sdF 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_indexeslenrX)selfvaluerAs 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_truerXgetr^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 rXrds 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)rXrcrb)r^eres 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.)rAr typingr AbstractSetrbr, __class__ _coerce_valueintmergercrange setdefault) r^rAv_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)rrrbr!rtrc)r4baseoverrider~rH merge_keysmerged merged_items r'rtzValueItems.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.rqz???z!Unexpected type of exclude value )r rorrprBfromkeysgetattrr,)rA class_names r'r[zValueItems._coerce_itemssf eV^^ ,   v11 2MM%-E ! U;J? |LM Mr)cN||j|r|S|j|Sr)rbr[)r4r_s r'rrzValueItems._coerce_value s( =CKK.L  ''r)c|duxs|duS)NT.r%s r'rbzValueItems.is_truesDy$AH$r)c d|jfgSrrh)r^s r' __repr_args__zValueItems.__repr_args__st{{#$$r)N)r_rrA$AbstractSetIntStr | MappingIntStrAnyreturnNone)rerrbool)rkz int | strrz+AbstractSetIntStr | MappingIntStrAny | None)rArrwrsrzdict[int | str, Any])F)rrrrr~rrr)rArrr)r_rrrr&rrr)rz_repr.ReprArgs)__name__ __module__ __qualname____doc__ __slots__r`rfrirlr\ classmethodrt staticmethodr[rrrbrrr)r'rWrWszY#I.3#8# J##J(( %%%r)rWcyrrnamer_s r'ClassAttributersr)c$eZdZdZdZddZddZy)rz(Hide class attribute from its instances.rc ||_||_yrr)r^rr_s r'r`zClassAttribute.__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)rrrrrr`rrr)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. ) rqrrr"r@r, 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_identicalrEs1"-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)rrcrr^keys r' __getitem__zSafeGetItemProxy.__getitem__as||Y//r)c8|jj|Sr)r __contains__rs r'rzSafeGetItemProxy.__contains__js<<,,S1 1r)N)rrrr)rrrr) rrrrr__annotations__rro TYPE_CHECKINGrrr)r'rrTs.I 0 2r)rr)r-rr.z(type[Any] | tuple[type[Any], ...] | Nonerr)r4rr.rrr)r4rrzTypeGuard[type[BaseModel]])r<rrr)rDdict[KeyType, Any]rErrr)rDzdict[Any, Any]rJrrr)rQzlist[T] | tuple[T, ...]rMztyping.Callable[[T], str]rzlist[T])rrr_rLrrL)rrrr)rtyping.Iterable[Any]rrrr)Or __future__r _annotations dataclassesr:roweakref collectionsrrrr@r itertoolsrtypesr r r r r rrrrtyping_extensionsrrrr _import_utilsrrrrrmainrrsfloatcomplexrrbytesr1NoneTyperefNotImplementedrqEllipsisrr!r#r"r$rBrr(r/r5r7r=r>rCrKrLrURepresentationrWrrrobjectrr dataclassrrr)r'rs 3 77!dd((2"3 "WiW#VyV     KK  '30     '^ NGK ) G CL /2', ,C%%%C%L 5 a aen& H  d#22$2r)