vhQUddlmZddlZddlmZmZmZmZddlZddlm Z ddl Z ddl Z ddl Z ddlZddlmZmZmZmZmZmZmZddlZddlZddlmZddlmZddlmZdd lm Z!e jDe#Z$eZ%eZ&ed Z'ed Z(ed Z)ed Z*esedkr(ed`dZ+edadZ+edbdZ+edcdZ+dZ+n e!jVZ+er(edddZ,ededZ,edfdZ,edgdZ,dZ,n e!jXZ,er(edhdZ-edidZ-edjdZ-edkdZ-dZ-n e!jZZ- dldZ. dmdZ/dnd Z0dod!Z1dod"Z2dpd#Z3 dqd$Z4 drd%Z5 dsd&Z6dtd'Z7dud(Z8e8Z9e:Z;dvd)Zd,<e e!j~d-Z@ dwd.ZAd/ZBdxd0ZCejaEd1ZFeCd2ZG dy dzd3ZejaHd4ZIGd5d6ZJGd7d8ZKGd9d:ZLd{d;ZMd|d}d<ZNd~d=ZOdd>ZPdd?ZQdd@ZR d ddAZSdBZTddCZUddDZVddEZWGdFdGZXdHZYGdIdJZZdKZ[dLZ\ddMZ]GdNdOee'Z^GdPdQZ_ddRZ`ddSZaddTZbdddUZcGdVdWejZeGdXdYeeZZfdZgd[e>d\<dd]Zheie!d^r e!jZjdd_Zky)) annotationsN)CallableIterableIteratorSequence)partial)AnyGeneric SupportsIndexTypeVaroverload TYPE_CHECKINGcast)config)jaxlib_extension_version)weakref_lru_cache)utilsTT1T2T3ibcyN)__arg1s H/opt/face_recognition/venv/lib/python3.12/site-packages/jax/_src/util.pysafe_zipr4s9<cyrr)r__arg2s rrr6sSVrcyrr)rr __arg3s rrr8smprcyrr)rr r"__arg4argss rrr:s MPrcD|s tdtt|ddiS)af Like builtin :func:`zip`, but with additional safety checks. The differences from :func:`zip` are: - :func:`safe_zip` checks that at least one argument is provided. - :func:`safe_zip` checks that all arguments have the same length. - :func:`safe_zip` returns an eagerly-evaluated list instead of a lazily-evaluated iterator. z&safe_zip requires at least 1 argument.strictT) TypeErrorlistzip)r%s rrr=s(  > ?? T'$' ((rcyrrfrs rsafe_mapr.SsGJrcyrrr-rr s rr.r.Vsadrcyrrr-rr r"s rr.r.Ys{~rcyrrr-rr r"r$r%s rr.r.\s TWrc ttt|}t|d}|ddD]1}t||k(rJdttt|tt|g|S)Nrzlength mismatch: )r)maplen)r-r%nargs rr.r._sr D$ D DG AABxG X]F/Sd^0D/EFF]G A  rcyrrr,s rforeachr<jsEHrcyrrr0s rr<r<ms_brcyrrr2s rr<r<psy|rcyrrr4s rr<r<ss RUrct|g|yr)r.)r-r%s rr<r<vs Q rcg}g}|D]'\}}|j||j|)t|t|fS)z2Unzip sequence of length-2 tuples into two tuples.appendtuple)xysxsysxys runzip2rJ~sL ""daIIaLIIaL rE"I rcg}g}g}|D]9\}}}|j||j||j|;t|t|t|fS)z4Unzip sequence of length-3 tuples into three tuples.rB)xyzsrFrGzsrHrIzs runzip3rOsd """gaAIIaLIIaLIIaL rE"IuRy ((rcLt|}|D] \}}|||< t|S)z Substitute values within a list.)r)rD)lstreplaceivs rsubvalsrUs1 S #da CF srct|}g}|D]}|j|d|||d}|j||S)0Split list into sublists of the specified sizes.N)r)rCr%nslistsr9s r split_listr[sO d$ % a LLbq 8D,,t ,rct|}t|t|k(rtd|DsJg}|D]}|j |d|||d}|S)rWc3&K|] }|dk\ yw)rNr).0r9s r z%split_list_checked..s%9a1f%9sN)r)sumr8allrCrXs rsplit_list_checkedrbsf d$ RCI #%9b%9"99 9 % a LLbq 8D ,rct|t|k(sJggf}t||D]\}}||j||S)z*Partition a list into two based on a mask.)r8r*rC)bslrZbrHs rpartition_listrgsO RCF  $&8%"ajda !HOOA ,rcVt|t|k(r#t|t|z t|k(sJt|t|}}|Dcgc]}|r t|n t|}}t }t||t||cxur|usJJ|Scc}w)z0Merge the elements of two lists based on a mask.)r`r8iternextobject)rdl0l1i0i1rfoutsentinels r merge_listsrrs RCG B#b' 1SW << < 8T"Xb"=?@AR483@#@ X( b( tB1 =X == == = *AsB&ct|}|Dcgc]}|||n t|}}t}t|||usJ|Scc}wr)rirjrk)subssrcbasebase_rSrprqs r subs_listrxsX t*%;?@a1=Qd5k 1@#@ X( eX ( ** * * AsAct|t|k(sJt|}t||Dcgc]\}}|||n|||n t| }}}t } t|| | usJ|Scc}}wr)r8rir*rjrk) subs1subs2src1src2rvrwf1f2rprqs r subs_list2rs Us5z !! ! t*%$'u$5 7 R^bR^b e  7# 7 X( eX ( ** * *  7s#A6cjt|}|Dcgc]}|j|}}|rJ|Scc}wr)dictpop)dctnamesnamerQs r split_dictrs7 S ##()4)#) . * *s0cRttjj|S)z&Concatenates/flattens a list of lists.)r)itchain from_iterable)rFs r concatenaters bhh$$R( ))rc t|}|Dcgc]$}t|Dcgc] }t|c}&}}}t|ttusJ|Scc}wcc}}w)zpSplits `xs` into subsequences of lengths `ns`. Unlike `split_list`, the `sum(ns)` must be equal to `len(xs)`.)rirangerj_unflatten_done)rFrYxs_iterr9_ unflatteneds r unflattenrsV H'<>?qq2A$w-2?+? g '? :: : 3?sAA AAc@t|tt|S)zCurries arguments of f, returning a function on any remaining arguments. For example: >>> f = lambda x, y, z, w: x * y + z * w >>> f(2,3,4,5) 26 >>> curry(f)(2)(3, 4, 5) 26 >>> curry(f)(2, 3)(4, 5) 26 >>> curry(f)(2, 3, 4, 5)() 26 )wrapsrr-s rcurryrs q''1% &&rz$Callable[[Iterable[Any]], list[Any]]toposortparentsctt||t|Dcgc] \}}|s | }}}t|Dcgc] \}}|r | }}}fd}|||fScc}}wcc}}w)Ncg}D]7}|r|j|d|dd}|j|d|dd}9|rJ|rJ|SNrr6)rC)new_lhsnew_rhsrpssidess rmergezsplit_merge..mergesg C   71:!"+ 71:!"+ ;; Jr)r)r7r*) predicaterFrHrlhsrhsrrs @r split_mergerso s9b! "%2u~+tq!+#+2u~/tq!Q/#/  c5 ,/s A#A# A)A)cyrrrrr_ignorersdrcfd}|S)Nctjfdtjfd}j|_j|_t j |j|S)Nc|i|Srr)rr%kwargsr-s rcachedz#cache..wrap..cached#s   rctjjr|i|Srtjn t g|i|Sr)rcheck_tracer_leaksvalue trace_contextr)r%rrr-trace_context_in_keys rwrapperz$cache..wrap..wrapper'sQ  " " ( ($!&!! .BF((* %%#%%r) functools lru_cacher cache_clear cache_infocache_clearing_funsadd)r-rrmax_sizers` @rwrapzcache..wrap"st" # __Q%% !,,G**GG//0 Nrr)rrrs`` rcacher!s +rc(tD] }| yr)r)clears rclear_all_cachesr6s" e G r)rctj|rtjnt||}t j ||S)a  Least recently used cache decorator with weakref support. The cache will take a weakref to the first argument of the wrapped function and strong refs to all subsequent operations. In all other respects it should behave similar to `functools.lru_cache`. )_weakref_lru_cacherrrr_weakref_lru_cachesr)callmaxsizer cached_calls rrr=s;#442fw++& rc:tD]}|jyr)rr)rs rclear_all_weakref_lru_cachesrOs(krceZdZdgZdZdZy) Unhashablevalc||_yrrselfrs r__init__zUnhashable.__init__V DHrc4|j|jk(Srrrothers r__eq__zUnhashable.__eq__Y 88uyy  rN)__name__ __module__ __qualname__ __slots__rrrrrrrSsg)!rrc$eZdZdgZdZdZdZy)Hashablerc||_yrrrs rrzHashable.__init___rrc,t|jSr)hashrrs r__hash__zHashable.__hash__bs >rc4|j|jk(Srrrs rrzHashable.__eq__errNrrrrrrrrrrrr\sg)!rrc$eZdZdgZdZdZdZy) WrapKwArgsrc||_yrrrs rrzWrapKwArgs.__init__krrc zttdt|jj DS)Nc3*K|] \}}||f ywrr)r^krTs rr_z&WrapKwArgs.__hash__..osBAq!fBs)rrDsortedritemsrs rrzWrapKwArgs.__hash__ns( B0@)ABB CCrc4|j|jk(Srrrs rrzWrapKwArgs.__eq__qrrNrrrrrrhsg)D!rrc|dz|zdzS)N()r)rtransform_names r wrap_namerts #  $s **rcrt|dd}||St|trt|jS|S)Nr)getattr isinstancerfun_namefunc)fun default_namers rrrxs: j$ '$  KW CHH  rct|dd}||St|trt|jSt |S)Nr)rrr fun_qual_namerr)r qual_names rrrs?c>40) W  "" #rctj|}| |cxkr|ksntd|d||dkr||z}|S)z?Canonicalize an axis in [-num_dims, num_dims) to [0, num_dims).zaxis z) is out of bounds for array of dimension r)operatorindex ValueError)axisnum_dimss rcanonicalize_axisrsM  $ d %X % uTF"KH:V WW AX (?D +rc||k(r|St|tr|f}t|tr|f}|Dcgc]}t||j}}|Dcgc]}t||j}}t t j|Dcgc] }||vs| }}t t||D]\}}|j|||j|Scc}wcc}wcc}wr) rintrndimrnprr*insert transpose)rHrudstarSpermdrs rmoveaxisr sCZ HS &CS &C/23! 1aff %3#3/23! 1aff %3#32771:& 7!3,! 7$ 7Sc]#daKK1 T  43 7sC$C) C.C.c| |z Srr)rHrIs r ceil_of_ratior s 27rc  dfd }|S)zs Like functools.wraps, but with finer-grained control over the name and docstring of the resulting function. c t}tddxsd}|jjtditdi|_|nj ||_tdd|_|nj d ||d|_td |j |_ |_ |S#t$rY|SwxYw) N__doc____dict____annotations__)rrz)rdocrr) rrrupdaterformatrrrr __wrapped__ Exception)rrrdocstrrnamestrwrappeds rrzwraps..wrappers  g d GY + 1rc ll'':r:;#G->Cc$_T'..T.2Jclw 6HIcn"NS'&--DDcDVD k .#,,Gcco J   J sCC CC)rrreturnrr)rrrrrs```` rrrs .rcDtdt|j)NzUnhandled case: )AssertionErrortyper)rHs rassert_unreachabler s )$q'*:*:);<==rcpd|cxkrt|ksnJ|t|f|d||fz||dzSNrr8tidxrs r tuple_insertr'sD c SV *c3q6]*  4CC6 AcdG ##rcnd|cxkrt|ksnJ|t|f|d|||dzdzSrr#)r%r&s r tuple_deleter)sA c CF )S#a&M)  4C1S1WX; rcvd|cxkrt|ksnJ|t|f|d||fz||dzdzSrr#r$s r tuple_updater+sH c CF )S#a&M)  4CC6 Ac!efI %%rc.eZdZdZdZdZdZdZdZy)HashableFunctiona Decouples function equality and hash from its identity. Local lambdas and function defs are reallocated on each function call, making the functions created on different calls compare as unequal. This breaks our caching logic, which should really only care about comparing the semantics and not actual identity. This class makes it possible to compare different functions based on their semantics. The parts that are taken into account are: the bytecode of the wrapped function (which is cached by the CPython interpreter and is stable across the invocations of the surrounding function), and `closure` which should contain all values in scope that affect the function semantics. In particular `closure` should contain all elements of the function closure, or it should be possible to derive the relevant elements of the true function closure based solely on the contents of the `closure` argument (e.g. in case some closed-over values are not hashable, but are entirely determined by hashable locals). c ||_||_yrr-closure)rr-r0s rrzHashableFunction.__init__s DFDLrct|tuxrH|jj|jjk(xr|j|jk(Sr)rr-r-__code__r0rs rrzHashableFunction.__eq__sH K+ + * FFOOuww// / * LLEMM )+rcXt|jj|jfSr)rr-r2r0rs rrzHashableFunction.__hash__s $,,/ 00rc&|j|i|Srrrr%rs r__call__zHashableFunction.__call__s 4664 "6 ""rcPd|jjd|jdS)Nz )r-rr0rs r__repr__zHashableFunction.__repr__s$ (t||nA FFrN) rrrrrrrr6r9rrrr-r-s!&+ 1#Grr-cfdS)Nct|Sr)r-r/s rz&as_hashable_function..s#Aw/rr)r0s`ras_hashable_functionr=s //rc$eZdZdZdZdZdZy)HashablePartialc.||_||_||_yrr-r%r)rr-r%rs rrzHashablePartial.__init__s DFDIDKrct|tuxrc|jj|jjk(xr4|j|jk(xr|j |j k(Sr)rr?r-r2r%rrs rrzHashablePartial.__eq__s` K? * D FFOOuww// / D II # D(, u||(CErctt|jjd}t |j j |j|fS)Nc |dSr"r)kvs rr<z*HashablePartial.__hash__..s ber)key)rDrrrrr-r2r%)rrs rrzHashablePartial.__hash__s? 6$++++-3CD EF $))V4 55rc\|jg|j|i|j|SrrAr5s rr6zHashablePartial.__call__ s- 466 =499 =t =t{{ =f ==rN)rrrrrrr6rrrr?r?s E 6>rr?cx tj|}d}|r||S|S#t$rd}YwxYw)NFT)rrr()rif_posif_namedposnameds rmaybe_named_axisrM sG .. C E!$1fSk1  Es + 99ctjjrdg} |j|ddd|dd|ddD]\}}|jd|d| |jdt j d j|yy#t$r-}|jd|j|Yd}~hd}~wwxYw) zFormat and log `pairs` if config.jax_distributed_debug is enabled. Args: pairs: A sequence of label/value pairs to log. The first pair is treated as a heading for subsequent pairs. z DISTRIBUTED_DEBUG_BEGINrz: r6Nz z!DISTRIBUTED_DEBUG logging failed!DISTRIBUTED_DEBUG_END )rdistributed_debugrrCrloggerwarningjoin)pairslineslabelres rdistributed_debug_logrYs ## ( )E lleAhqk]"U1Xa[M23),,% r%5'*+,  LL() NN499U#$$  ll67 llaSsAB C&#CCcHtj|jS)zbReturns unique elements from `it` in the order of occurrence. The elements must be hashable. )rfromkeyskeys)rs r stable_uniquer])s r    !!rcPeZdZUded<ded<dZd dZd dZddZdd Zdd Z y ) OrderedSetzset[T]elts_setlist[T] elts_listc0t|_g|_yr)setr`rbrs rrzOrderedSet.__init__5sEDMDNrc||jvr7|jj||jj|yyr)r`rrbrCrelts rrzOrderedSet.add9s7 $-- mm nnC  rc4|D]}|j|yr)r)reltsrXs rrzOrderedSet.update>s  hhqkrc,t|jSr)rirbrs r__iter__zOrderedSet.__iter__Bs  rc,t|jSr)r8rbrs r__len__zOrderedSet.__len__Es t~~ rc||jvSr)r`rfs r __contains__zOrderedSet.__contains__Hs $-- rN)rgrrNone)rizSeq[T]rrp)rz Iterator[T])rr)rgrrbool) rrrrrrrrkrmrorrrr_r_1s,  !   rr_c4eZdZUded<ded<dZdZdZy) HashableWrapperr rHz int | NonercN||_t||_y#d|_YyxYwr)rHr)rrHs rrzHashableWrapper.__init__Os DF!WDIs $c\|j |jSt|jSr)ridrHrs rrzHashableWrapper.__hash__Ss" -499=2dff:=rct|tsy|j|j|jk(S|j|juS)NF)rrsrrHrs rrzHashableWrapper.__eq__Us= e_ -  $ 5466UWW L466UWW;LLrN)rrrrrrrrrrrsrsLs&>Mrrsct|trtt|jSt|tj r |j S|Sr)rpropertyrfgetrcached_propertyrrs r_original_funcr|[s=8 !  ! !!!Y../ 66M (rcdfd }|S)Nc|_|Sr)r)rmodules rrzset_module..wrapperds do Kr)rrrrr)rrs` r set_modulercs .rcfd}|S)zEA decorator replacing a Python class with its C++ version at runtime.c|Shd}|jjD]-\}}||vs tt|dr!t ||/|j _S)N>rrr_use_cpp)rrhasattrr|setattrr)clsexclude_methods attr_nameattrcpp_clss rrzuse_cpp_class..wrappernsg j;O<<--/, 4 / )~d+Z8 '9d +, kkGO Nrr)rrs` r use_cpp_classrks  .rcHtts tdfd}|S)zKA decorator excluding methods from the set that are forwarded to C++ class.z``is_enabled`` must be a boolc0rt|}d|_|S)NT)r|r)r- original_func is_enableds r decoratorz!use_cpp_method..decorators$Q'm#m Hr)rrqr()rrs` ruse_cpp_methodr~s& J % 3 44 rcFeZdZdZdZej ZejZy) StrictABCMetaa%A variant of `abc.ABCMeta` which does not allow virtual subclasses. Virtual subclasses support require `abc.ABCMeta` to roundtrip through pure Python when doing instance/subclass checking. This if fine for ABCs which need virtual subclasses, but is wasteful for the ones which don't. c ~t|d)Nz$ does not support virtual subclasses)NotImplementedError)rsubclasss rregisterzStrictABCMeta.registers %IJ KKrN)rrrrrr__instancecheck____subclasscheck__rrrrrs' L,,,,rrceZdZdZy) StrictABCrN)rrrrrrrrrs)rr) metaclasszCallable | Nonetest_event_listenerc*tsyt|g|yr)r)rr%s r test_eventrs  d"T"rMutexcd}|dkryttjtj|dt |dz }|d|zz }|d||dS)N)rKMGrrz0.00Bir6z.2fB)minmathfloorlogr8) num_bytesprefixesexponent scaled_values r pprint_bytesrsb %(!^  DHHY56H 8I J(dHn-,  hx01 33r)r Iterable[T1]rzlist[tuple[T1]])rrr Iterable[T2]rzlist[tuple[T1, T2]])rrr rr" Iterable[T3]rzlist[tuple[T1, T2, T3]]) r Iterable[Any]r rr"rr$rrzlist[tuple[Any, ...]])r-zCallable[[T1], T]rrrra)r-zCallable[[T1, T2], T]rrr rrra) r-zCallable[[T1, T2, T3], T]rrr rr"rrra) r-zCallable[..., T]rrr rr"rr$rrra)r-zCallable[[T1], Any]rrrrp)r-zCallable[[T1, T2], Any]rrr rrrp) r-zCallable[[T1, T2, T3], Any]rrr rr"rrrp) r-zCallable[..., Any]rrr rr"rr$rrrp)rEzIterable[tuple[T1, T2]]rz%tuple[tuple[T1, ...], tuple[T2, ...]])rLzIterable[tuple[T1, T2, T3]]rz5tuple[tuple[T1, ...], tuple[T2, ...], tuple[T3, ...]])rQ Sequence[T]rRzIterable[tuple[int, T]]r tuple[T, ...])r%rrY Sequence[int]r list[list[T]])rdSequence[bool]rerrztuple[list[T], list[T]])rdrrl Sequence[T1]rmz Sequence[T2]rz list[T1 | T2])rtSequence[int | None]rurrvrrra) rzrr{rr|rr}rrvrrra)rz dict[T1, T2]rrrzlist[T2])rFzIterable[Sequence[T]]rra)rF Iterable[T]rYrrr)rzCallable[[T], bool]rFrrzFtuple[list[T], list[T], Callable[[Sequence[T], Sequence[T]], list[T]]])iT)iT)rrrrq)rstrrrrr)z)rrrrrr)rrrr)rr rrrr)rHArrayruint | Sequence[int]rrrr)rHrrIrrr)NN)rrr str | NonerrrCallable[[T], T])r%rr&rrrrr)r%rr&rrr)rrrr)r-rrr)rrrr)rz type[Any]rzCallable[[type[T]], type[T]])T)rrqrr)rrrrp)rz int | floatrr)l __future__rabccollections.abcrrrrrr itertoolsrloggingrrtypingr r r r r rrweakrefnumpyrjax._srcr jax._src.librrrr jaxlib_utils getLoggerrrRSeqrrrrrrr.r<rJrOrUr[rbrgrrrxrrrflattenrkrrrrtopological_sortrrrrWeakSetrrmemoizerrrrrrrrrr r rr r'r)r+r-r=r?rMrYr]r_rsr|rrrABCMetarrrrrrrrrrrs # BB XXX1@.   8 $  CL T] T] T],s2 < < V V p p P P ) " "( J J d d ~ ~ W W " "( H H b b | | U U  '  .  ) > )        #    %0 8C       (<    (  0;      * (' /. <00) <"L,&&goo'  .237,0 &goo'!! ! ! ! !+       <>$&$G$GL0>>$2%("  6 M M &  -CKK --(,_+#  <!   %4r