Cd UddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZmZmZmZddlmZmZmZddlmZmZddlmZddlmZddlmZdd lmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)dd l*m+Z+ddl,Z-ddl.Z.ddl.m/Z/ddl0m1Z1e(dZ2e(dZ3e(dZ4ej5Z6e6dkrdZ6ddZ7dddde8dddZ9dZ:e9d Z;d!Zedd%Z?ed#e@d&fd'ZAed(ZBedd)ZCGd*d+ZDee@d,d-fd.ZEd/ZFddd2ZGddd5ZHdd7ZIheJeKeLeMeNeOePeQeReSeTeUeVeWeXeYeZe[e\e]e^e_e`eaebecedeeefe@egeheiejekelemeneoepeqereseteuevZwexeyeze{e|e}e~eeeeh Zd8Zdd9Zdd;ZGd<d=Zdd?Zd@ZdAZdBZddCZdDZ ddEZ ddFZddHZdddMZddOZddPZdQZdRZdSZdTZdUZdVZiZdWedX<GdYdZZGd[d\ZGd]d^ZeZGd_d`ZddaZdIdbddgZdIdbddkZGdldmZdnZddoZddpZddqZddrZddsZdduZddwZdxdydzd{d|d}d~dddddd ZdeDZedeDedeDddZddZddZdddddddddZdddddddddZedeDeeedeDe)dddZe) dddZddZdZdZdZejxdZejddZdddZdZGddejZGddZejdZddZddZddZddZddZdZdS)) annotationsN)HashableIterableIteratorMappingSet)contextmanager nullcontextsuppress)datetime timedelta)ENOENT) lru_cache) import_module)IntegralNumber)add)Lock)AnyClassVarLiteralTypeVaroverload)WeakValueDictionary)config)get_depsKVTasciizutf-8c |r||i|S||S)aApply a function given its positional and keyword arguments. Equivalent to ``func(*args, **kwargs)`` Most Dask users will never need to use the ``apply`` function. It is typically only used by people who need to inject keyword argument values into a low level Dask task graph. Parameters ---------- func : callable The function you want to apply. args : tuple A tuple containing all the positional arguments needed for ``func`` (eg: ``(arg_1, arg_2, arg_3)``) kwargs : dict, optional A dictionary mapping the keyword arguments (eg: ``{"kwarg_1": value, "kwarg_2": value}`` Examples -------- >>> from dask.utils import apply >>> def add(number, second_number=5): ... return number + second_number ... >>> apply(add, (10,), {"second_number": 2}) # equivalent to add(*args, **kwargs) 12 >>> task = apply(add, (10,), {"second_number": 2}) >>> dsk = {'task-name': task} # adds the task to a low level Dask task graph )funcargskwargss *lib/python3.11/site-packages/dask/utils.pyapplyr')s->tT$V$$$tT{)version after_versionmessage use_insteadcategoryr) str | Noner*r+r,r- type[Warning]c"fd}|S)a&Decorator to mark a function as deprecated Parameters ---------- version : str, optional Version of Dask in which the function was deprecated. If specified, the version will be included in the default warning message. This should no longer be used after the introduction of automated versioning system. after_version : str, optional Version of Dask after which the function was deprecated. If specified, the version will be included in the default warning message. message : str, optional Custom warning message to raise. use_instead : str, optional Name of function to use in place of the deprecated function. If specified, this will be included in the default warning message. category : type[Warning], optional Type of warning to raise. Defaults to ``FutureWarning``. Examples -------- >>> from dask.utils import _deprecated >>> @_deprecated(after_version="X.Y.Z", use_instead="bar") ... def foo(): ... return "baz" c8jd ddz n ddz ndz dz  ddz ntjfd}|S) N zwas deprecated after version zwas deprecated in version zis deprecated z(and will be removed in a future release.z Please use z instead.cBtjd|i|S)N)r- stacklevel)warningswarn)r$r%r-r#msgs r&wrapperz/_deprecated..decorator..wrappers/ M#Q ? ? ? ?4((( (r()__name__ functoolswraps)r#r9r8r*r-r+r,r)s` @r& decoratorz_deprecated..decoratorss ?]%%%C(G}GGGG$>G>>>>'' = =C&Ns=J. r(c|t|dttfrfdt|DS|S)zApply function inside nested lists >>> inc = lambda x: x + 1 >>> deepmap(inc, [[1, 2], [3, 4]]) [[2, 3], [4, 5]] >>> add = lambda x, y: x + y >>> deepmap(add, [[1, 2], [3, 4]], [[10, 20], [30, 40]]) [[11, 22], [33, 44]] rc*g|]}tg|RSr")deepmap).0itemsr#s r& zdeepmap..s)>>>%%u%%%>>>r() isinstancelistrzip)r#seqss` r&rArAsJ$q'D(+,,>>>>3:>>>>tT{r(c|s|Sd}|}t|tr"|dz }|d}t|t"t|||SNr)rErFndeepmap)r#seqntmps r&homogeneous_deepmaprPse   A C S$   Q!f S$   AtS ! !!r(cdkrfd|DSdkrfd|DSt|tr|dS|S)zCall a function on every element within a nested container >>> def inc(x): ... return x + 1 >>> L = [[1, 2], [3, 4, 5]] >>> ndeepmap(2, inc, L) [[2, 3], [4, 5, 6]] rKc&g|] }|Sr"r")rBitemr#s r&rDzndeepmap..s!+++tT +++r(c8g|]}tdz |S)rK)rL)rBrSr#rNs r&rDzndeepmap..s)<<<Qd++<<>( # # ('"" ( (7==**(M(++++Ih'''  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (27>>( # # ('"" ( (7==**(M(++++Ih'''  ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (sD!C=A C..C25C2=4F1A F: FF F F Fc#PKtj|} |Vtj|rtj|rCt t5tj |ddddS#1swxYwYdSt t5tj |ddddS#1swxYwYdSdS#tj|rtj|rAt t5tj |dddw#1swxYwYwt t5tj |dddw#1swxYwYwwxYw)a Function to create and return a unique temporary directory. Parameters ---------- dir : str If ``dir`` is not None, the directory will be created in that directory; otherwise, Python's default temporary directory is used. Returns ------- out : str Path to the temporary directory Notes ----- This context manager is particularly useful on Windows for opening temporary directories multiple times. r_N) rbmkdtemprdrgrhrjr rirkrlrfr`dirnames r&tmpdirrus(3'''G ' 7>>' " " 'w}}W%% 'g&&++M'***++++++++++++++++++g&&''Ig&&&''''''''''''''''''  ' '27>>' " " 'w}}W%% 'g&&++M'***++++++++++++++++g&&''Ig&&&''''''''''''''''  'sxC#/BBB2CCC#AF%6E F%E F%E F%7F F%F F%F F%wc#JKt|5}|||} || |n:#t$rYn.wxYw# |w#t$rYwwxYwxYw|VddddS#1swxYwYdS)N)rm)mode)rpwritereAttributeError)textrmopenrxrofs r&filetextr~s 9 % % %  D % % %  GGDMMM  !      !                      siBAA  B ABABBA43B4 B >BB BBBBc#Ktj}tj| dVtj|dS#tj|wxYwN)rdgetcwdchdir)new_cwdold_cwds r& changed_cwdr's[ikkGHW  s AAc#Kt|5}t|5|Vdddn #1swxYwYddddS#1swxYwYdSr)rurrss r&tmp_cwdr1s   ! !  MMM               s,A 3 A 7 A 7 A  AAc"eZdZdZdZdZdZdS) IndexCallablezProvide getitem syntax for functions >>> def inc(x): ... return x + 1 >>> I = IndexCallable(inc) >>> I[3] 4 fnc||_dSrr)selfrs r&__init__zIndexCallable.__init__Es r(c,||Srr)rkeys r& __getitem__zIndexCallable.__getitem__Hswws||r(N)r: __module__ __qualname____doc__ __slots__rrr"r(r&rr8sCIr(rtTc#K|rtn t5|D]\}} tjtj|n#t$rYnwxYw||d|z} || | #t$rYwxYw# | w#t$rYwwxYwxYwt|V|D]a}tj |r@tt5tj|dddn #1swxYwYb ddddS#1swxYwYdS)aSDumps a number of textfiles to disk Parameters ---------- d : dict a mapping from filename to text like {'a.csv': '1,1 2,2'} Since this is meant for use in tests, this context manager will automatically switch to a temporary current directory, to avoid race conditions when running tests in parallel. rvN)rr rCrdmakedirsrgrtriryrerzrFrhr rf)dr|rx use_tmpdirror{r}s r& filetextsrLs(! 3kmm((ggii  NHd  BGOOH556666    XsTz**A  GGIIII%DGGIIII%D1gg  ( (Hw~~h'' (g&&((Ih'''((((((((((((((( (#((((((((((((((((((sE61A.-E6. A;8E6:A;;E6C $B98E69 CE6CE6 C0 C C0 C- *C0,C- -C00A E6;E E6E E6#E $E66E:=E:ct|trt|}t|ttfr"tt t |}|S)zMake nested iterators concrete lists >>> data = [[1, 2], [3, 4]] >>> seq = iter(map(iter, data)) >>> concrete(seq) [[1, 2], [3, 4]] )rErrFtuplemapconcreterMs r&rrpsS#x  3ii#t}%%'3x%%&& Jr(rNintcddl}t|}|dg|z}|d|dsJt |dksJt ||jjs|j|}||}| |d}tt|dd|ddD]\}\}} ||||k|| kz<|S)zPseudorandom array of integer indexes >>> pseudorandom(5, [0.5, 0.5], random_state=123) array([1, 0, 0, 1, 1], dtype=int8) >>> pseudorandom(10, [0.5, 0.2, 0.2, 0.1], random_state=5) array([0, 2, 0, 3, 0, 1, 2, 1, 0, 0], dtype=int8) rNrKi1dtype) numpyrFcumsumallcloselenrErandom RandomState random_sampleempty enumeraterG) rNp random_statenpcpxoutilowhighs r& pseudorandomrs QA A37  B ;;q"R& ! !!!! q66C<<<< lBI$9 : :;y,,\:: ""1%%A ((1D( ! !C#C3B3ABB$8$899));C'(Q#X!d( #$$ Jr(returnrFcVddl}tfddDs|jd|zdz}t |||j|df}t||ksJ|S) aReturn a list of arrays that can initialize ``np.random.RandomState``. Parameters ---------- n : int Number of arrays to return. random_state : int or np.random.RandomState, optional If an int, is used to seed a new ``RandomState``. rNc38K|]}t|VdSrhasattr)rBattrrs r& z$random_state_data..s>(, d##r()normalbetabytesuniformiprr) rallrrrrF frombufferuint32reshaper)rNrr random_datals ` r&random_state_datars 0V  ;y,,\:: $$S1Wq[11K R]];bi] 8 8 @ @!R I IJJA q66Q;;;; Hr(boolc~t|tp(t|to|S)zj >>> is_integer(6) True >>> is_integer(42.0) True >>> is_integer('abc') False )rErfloat is_integer)rs r&rrs0 a " " Oz!U';';'N Or(ct|tjrt|jSt |d|}t|t rtj|j Stj|S)z@Version of inspect.getargspec that works with partial and warps. __wrapped__) rEr;partial getargspecr#getattrtypeinspectgetfullargspecr)r#s r&rrsn$ )**%$)$$$ 4 - -D$,%dm444%d+++r(cr|tvrdS|tvrdS t|}n#t$rYdSwxYw |jddkot |t }n#t$rd}YnwxYw|r |jrdS|jdnt|j}t|j|z |z dkS)aDoes this function take multiple arguments? >>> def f(x, y): pass >>> takes_multiple_arguments(f) True >>> def f(x): pass >>> takes_multiple_arguments(f) False >>> def f(x, y=None): pass >>> takes_multiple_arguments(f) False >>> def f(*args): pass >>> takes_multiple_arguments(f) True >>> class Thing: ... def __init__(self, a): pass >>> takes_multiple_arguments(Thing) False FTrrNrK) ONE_ARITY_BUILTINSMULTI_ARITY_BUILTINSr Exceptionr$rErvarargsdefaultsr)r#rspecis_constructor ndefaultss r&takes_multiple_argumentsr s2 !!!u % % %t$ uu1/JJtT4J4J 4<t]*DM0B0BI ty>>I % 6 ::s( 66&A!! A0/A0 list[str]cptj|}d|jDS)z7Get all non ``*args/**kwargs`` arguments for a functioncNg|]"\}}|j|j|j|jfv |#Sr")kindPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY KEYWORD_ONLY)rBrNrs r&rDz"get_named_args..;sB    Aq 6a-q/@!.Q Q Q Q Q Qr()r signature parametersrC)r#ss r&get_named_argsr8sA$A  L&&((   r(cLeZdZdZd dZd dZd dZdZdZe dZdS) DispatchzSimple single dispatch.Nc8i|_i|_|r ||_dSdSr)_lookup_lazyr:)rnames r&rzDispatch.__init__Es-   ! DMMM ! !r(c0fd}| ||n|S)z7Register dispatch of `func` on arguments of type `type`c~ttrD]}||n |j<|Sr)rErregisterr)r#rrrs r&r9z"Dispatch.register..wrapperNsS$&& *++AMM!T****+&* T"Kr(r")rrr#r9s`` r&rzDispatch.registerKs;      !% 0wwt}}}g=r(c0fd}| ||n|S)z Register a registration function which will be called if the *toplevel* module (e.g. 'pandas') is ever loaded. c|j<|Sr)r)r#rtoplevels r&r9z'Dispatch.register_lazy..wrapper^s#'DJx Kr(r")rrr#r9s`` r& register_lazyzDispatch.register_lazyXs;       !% 0wwt}}}g=r(c|j}|jD]} ||}||ur|||<|cS#t$rYnwxYw|jd\}}} |j|}||j|d||cS#t$rYwxYwtd|)z8Return the function implementation for the given ``cls``r^NzNo dispatch for ) r__mro__KeyErrorr partitionrpopdispatch TypeError)rclslkcls2implr_rs r&rzDispatch.dispatchds  \K * *D $xd??"BsG     "_66s;;NHa *:h/  x...}}S)))))      0300111s' 44 B B,+B,c^|t|}||g|Ri|S)zJ Call the corresponding method based on type of argument. )rr)rargr$r%meths r&__call__zDispatch.__call__}s;}}T#YY''tC)$)))&)))r(cz |t}|jS#t$r d|jzcYSwxYw)NzSingle Dispatch for %s)robjectrrr:)rr#s r&rzDispatch.__doc__sN <==((D<  < < <+dm; ; ; ; > > > > > > >2222***<<X<<9>c|}|dks|dr|Sd|vrd|vrd|vr|dzS|dzS|S)Nz>>>z>>> #z+SKIPz # doctest:z, +SKIPz # doctest: +SKIP)strip startswith)linestrippeds r& _skip_doctestrsnzz||H5H//88 (  wh66 4  )# #.. . r(cn|dSdd|dDS)Nr\ c,g|]}t|Sr")r)rBrs r&rDz skip_doctest..s FFFdmD))FFFr()joinsplit)docs r& skip_doctestr s7 {r 99FFciiooFFF G GGr(c|dfdttdz D}t}t |D]\}}||vrjd|z}||||<|dzdt|zdt|z|dz<s||dS)Nrci|]n}|dztd|dzDS||oS)rKc3"K|] }|dkV dS)-Nr")rBcs r&rz*extra_titles...s&'O'OQS'O'O'O'O'O'Or()rr)rBrliness r& z extra_titles..s Q<    %('O'O%A,:L:L:N:N'O'O'O$O$O 58>>  r(rKzExtra r$) rrangersetsortedrCreplacerr)rtitlesseenrtitle new_titler&s @r& extra_titlesr0s  IIdOOEs5zzA~&&F 55D6<<>>**5 D== 5(IQx''y99E!H Q<//c%jj0@#IBVWWE!a%LL HHUOOOO 99U  r(cddl}|j|r"d|j|j|}nd|jd|d}d}|d} | d kr|d| d z} || d zd} |dkr:| d} | d| d z} | | d zd} |d z}|dk:t jd | d} |r| | d dzg} ng} |d|}| | ||d|dg| z| gz}n| | || |dg| z| gz}d |}|S)z4Expand docstring by adding disclaimer and extra textrNz*This docstring was copied from {}.{}.{}. zThis docstring was copied from r^z. z5Some inconsistencies with the Dask version may exist. rr4rKz\s*rzKnown inconsistencies: r\) risclassformatrr:findrematchgrouprstripr)rrrextra skipblocksinconsistenciesrl1l2rheadtailindentmorel3bitss r&ignore_warningrEsNNNwsJ ; B B N L    Js| I Id I I I @B ABww7QU7|1q577|1nn &!!A!a%=DA=D !OJ 1nn &$''--a00  ELL..78DDD  &?o??B&"b&"f=DvMDD&"fb&9D@D6IDggdmm Jr(c|d}|D]?fdt|D}t|dkr|\\}}|dz||<@d|S)z,Mark unsupported arguments with a disclaimerrcTg|]$\}}tjdzdz| ||f%S)z^\s*z ?:)r6r7)rBrrr s r&rDz)unsupported_arguments..sL   4x# -t44 I   r(rKz (Not supported in Dask))rrrr)rr$r&subsetrrr s @r&unsupported_argumentsrIs IIdOOE::    $U++    v;;!   KYa99E!H 99U  r(c |pg}t||j}t|dd}t|tr|j}|st|dd}|d}|sH|jdvr?|D]*}t||jd} | | jr | j}n+|rt|||j|||}n|r||ddzz } t| t|} fd| D} n#t$rg} YnwxYwt|d kr| |t| d krt|| }t|}t|}|S) z0Helper function for derived_from to ease testingrNr\>Series DataFrame)r:r;r<rr2cg|]}|v| Sr"r")rBm method_argss r&rDz!_derived_from..&s#JJJqQk5I5I5I5I5Ir(r)rr:rErfgetmrorrEr9r ValueErrorrextendrIr r0) rmethodua_argsr:r;r<original_methodrobj obj_method original_args not_supportedrOs @r& _derived_fromr[smGc6?33O /9d 3 3C/8,,<). </9d;;C { 3<#:::7799  C fot<.wrapper..wrapped`sFJvJJJ&FD4;;{G<<.wrapperPs FIt44:E*% / FNM   (399#>>qAK _V $ $ / / / / / /% $ /NNN s.4A BBr")rcr)rUr;r<r9s````` r& derived_fromrd4sF4mG4 Nr(strcDt|tjrt|jSt|t r|jddSt|ddpd}tt|ddpd}d|vrd|kr|j ddSd|vrd |kr|j ddSd |vr%d |krd t|j zddS |j }|d krdS|ddS#t$rt|ddcYSwxYw)zGet the name of a function.N2rr\r:toolzcurrymultipledispatch Dispatcherr vectorize vectorize_zlambda)rEr;rfuncnamer# methodcallerrTrr func_namerpyfuncr:rzre)r#ra type_namers r&roroms]$ )**# """$ %% {3B3$ d339rKT J55;I+'Y"6"6~crc""[((\Y-F-Fy"~++":":x 444crc::} :  8CRCy 4yy"~s" C;1 C;;!DDFtyprshortc<t|tstt|S |jr |jdkr|jS|r|jd^}}n|j}|dz|jzS#t $rt|cYSwxYw)z Return the name of a type Examples -------- >>> typename(int) 'int' >>> from dask.core import literal >>> typename(literal) 'dask.core.literal' >>> typename(literal, short=True) 'dask.literal' builtinsr^)rErtypenamerr:rrzre)rtrumodulers r&rxrxs c4 #S """ ~ /:!=!=<  ( ^11#66 C<#,. . 3xxsA? 2A??BBrct|tr|St|dr|S t|S#t$r}t d|d|d}~wwxYw)aAttempt to turn `s` into bytes. Parameters ---------- s : Any The object to be converted. Will correctly handled * str * bytes * objects implementing the buffer protocol (memoryview, ndarray, etc.) Returns ------- b : bytes Raises ------ TypeError When `s` cannot be converted Examples -------- >>> ensure_bytes('123') b'123' >>> ensure_bytes(b'123') b'123' >>> ensure_bytes(bytearray(b'123')) b'123' encodeObject z6 is neither a bytes object nor can be encoded to bytesN)rErrr{rrrrZs r& ensure_bytesr~s:!U  H  xxzz 88O   S!SSS  sA A/A**A/ct|tr|St|dr|S t j|S#t $r}t d|d|d}~wwxYw)zuTurn string or bytes to string >>> ensure_unicode('123') '123' >>> ensure_unicode(b'123') '123' decoder|z2 is neither a str object nor can be decoded to strN)rErerrcodecsrrr}s r&ensure_unicoders!S  H  xxzz =## #   O!OOO  sA A4A//A4c|||zz|zS)z >>> digit(1234, 0, 10) 4 >>> digit(1234, 1, 10) 3 >>> digit(1234, 2, 10) 2 >>> digit(1234, 3, 10) 1 r")rNkbases r&digitrs a<$ r(cHt|}|||<t|S)zB >>> insert(('a', 'b', 'c'), 0, 'x') ('x', 'b', 'c') )rFr)tuplocvalLs r&insertrs# S A AcF 88Or(ct|\}tdfdtfdDS)N)maxsizecd|sdSdtfd|Dz}|S)NrKc3.K|]}|VdSrr"rBdep_keymax_depth_by_depss r&rz>dependency_depth..max_depth_by_deps.. s/HH7%%g..HHHHHHr()max)rrdepsrs r&rz+dependency_depth..max_depth_by_depssDCy 1 HHHHd3iHHHHH Hr(c3.K|]}|VdSrr"rs r&rz#dependency_depth..s/EEg  ))EEEEEEr()rrrkeys)dskrrrs @@r&dependency_depthrstsmmGD!t EEEEEEE E EEr(c:dD]}|dkr |dd|cS|dz}dS)N)rKBMBGBTBg@z3.1fr2r")numrs r& memory_reprrsL . <<$$$$$ $ $ $ v r(cd|D}td|D}tdtt||D}ddt|zz|zt|z}ddd|Dz}d fd |D}d |||||gS) zFormats an ascii table for given columns and rows. Parameters ---------- columns : list The column names rows : list of tuples The rows in the table. Each tuple must be the same length as ``columns``. c@g|]}td|DS)c34K|]}t|VdSrrerBrs r&rz(asciitable...$s($$Q#a&&$$$$$$r()r)rBrs r&rDzasciitable..$s/ 3 3 3E$$!$$$ $ $ 3 3 3r(c34K|]}t|VdSrrrs r&rzasciitable..%s(,,qCFF,,,,,,r(c 3K|]D\}}tttt|t|VEdSr)rrr)rBrr%s r&rzasciitable..&sFVVTQ3s3sA;;''Q00VVVVVVr(|z %%-%ds |z+%s++c3&K|] }d|dzzV dS)r$r4Nr")rBrvs r&rzasciitable..)s*::aC1q5M::::::r(rc3"K|] }|zV dSrr")rBr row_templates r&rzasciitable..*s(44!\A%444444r()rrGrr)columnsrowswidthsheaderbardatars @r& asciitablers 4 3d 3 3 3D,,G,,,,,G VVSdW=U=UVVV V VF;W56&@L E'NN *F 388::6::::: :C 994444t444 4 4D 99c63c2 3 33r(ctd|Dr d|D}|d|dS)Nc3BK|]}t|t VdSr)rErerBrs r&rzput_lines../s/ 1 1az!S!! ! 1 1 1 1 1 1r(c,g|]}t|Sr"rrs r&rDzput_lines..0s'''AQ'''r(r)anyryr)bufr&s r& put_linesr.sX 1 15 1 1 111('''''IIdiir(zdict[str, methodcaller] _method_cachecXeZdZUdZdZded<ed dZd dZdZ d Z d Z e Z d S)rpz Return a callable object that calls the given method on its operand. Unlike the builtin `operator.methodcaller`, instances of this class are cached and arguments are passed at call time instead of build time. rTrerTrc|jSrrrs r&r#zmethodcaller.funcBs {r(c t|S#t$r0t|}||_|t|<|cYSwxYwr)rrr __new__rT)rrTrs r&rzmethodcaller.__new__GsX  ( (   >>#&&D DK$(M& !KKK  s 7A A c8t||j|i|Sr)rrT)r_methodcaller__objr$r%s r&r zmethodcaller.__call__Ps#*wudk**D;F;;;r(c t|jffSr)rprTrs r& __reduce__zmethodcaller.__reduce__Sst{n--r(c2d|jjd|jdSN) __class__r:rTrs r&__str__zmethodcaller.__str__Vs"<4>*<>> a = [1, 3, 3] >>> M.count(a, 3) == a.count(3) True c t|Sr)rp)rrSs r& __getattr__zMethodCache.__getattr__ysD!!!r(c*ttSr)rFrrs r&__dir__zMethodCache.__dir__|sM"""r(N)r:rrrrrr"r(r&rrns<"""#####r(rceZdZUdZeZded<ded<ded<ddd Zd Zd Z d Z dZ dZ dZ dZdZeZdS)SerializableLockaA Serializable per-process Lock This wraps a normal ``threading.Lock`` object and satisfies the same interface. However, this lock can also be serialized and sent to different processes. It will not block concurrent operations between processes (for this you should look at ``multiprocessing.Lock`` or ``locket.lock_file`` but will consistently deserialize into the same lock. So if we make a lock in one process:: lock = SerializableLock() And then send it over to another process multiple times:: bytes = pickle.dumps(lock) a = pickle.loads(bytes) b = pickle.loads(bytes) Then the deserialized objects will operate as though they were the same lock, and collide as appropriate. This is useful for consistently protecting resources on a per-process level. The creation of locks is itself not threadsafe. z-ClassVar[WeakValueDictionary[Hashable, Lock]]_locksrtokenrlockNHashable | Nonec|pttj|_|jtjvrtj|j|_dSt|_|jtj|j<dSr)reuuiduuid4rrrrrrrs r&rzSerializableLock.__init__se/c$*,,// :)0 0 0(/ ;DIIIDI26)  #DJ / / /r(c&|jj|i|Sr)racquirerr$r%s r&rzSerializableLock.acquire ty $1&111r(c&|jj|i|Sr)rreleasers r&rzSerializableLock.releaserr(c8|jdSr)r __enter__rs r&rzSerializableLock.__enter__s r(c$|jj|dSr)r__exit__)rr$s r&rzSerializableLock.__exit__s D!!!!r(c4|jSr)rlockedrs r&rzSerializableLock.lockedsy!!!r(c|jSr)rrs r& __getstate__zSerializableLock.__getstate__s zr(c0||dSr)rrs r& __setstate__zSerializableLock.__setstate__s er(c2d|jjd|jdSr)rr:rrs r&rzSerializableLock.__str__s";4>*;;dj;;;;r(r)rr)r:rrrrrrrrrrrrrrrrr"r(r&rrs6=P>> from operator import add >>> partial_by_order(5, function=add, other=[(1, 10)]) 15 functionr)rrFr)r$r%r9rargs2rr s r&partial_by_orderr;#spzz*%%H JJw  E JJE3 Q 8U %f % %%r(c`ddlmt|dpt|d}tt|dojt |jt oPt|do@tfd|jD o|pdtt|vS) aIIs this object a numpy array or something similar? This function tests specifically for an object that already has array attributes (e.g. np.ndarray, dask.array.Array, cupy.ndarray, sparse.COO), **NOT** for something that can be coerced into an array object (e.g. Python lists and tuples). It is meant for dask developers and developers of downstream libraries. Note that this function does not correspond with NumPy's definition of array_like, which includes any object that can be coerced into an array (see definition in the NumPy glossary): https://numpy.org/doc/stable/glossary.html Examples -------- >>> import numpy as np >>> is_arraylike(np.ones(5)) True >>> is_arraylike(np.ones(())) True >>> is_arraylike(5) False >>> is_arraylike('cat') False r)is_dask_collection__array_function____array_ufunc__shaperc3.K|]}|VdSrr")rBrNr=s r&rzis_arraylike..Ts/;;a&&q));;;;;;r(z scipy.sparse) rr=rrrEr@rrrxr)r is_duck_arrayr=s @r& is_arraylikerC2s4-,,,,,A344UCT8U8UM 7 C qw & & C Aw   C;;;;17;;;;; ; C Ana0A0AA   r(cjjjjfdkrdSjtfddDo6tfddDot fddD S) zLooks like a Pandas DataFrame)zpandas.core.framerLTc38K|]}t|VdSrrrBrrts r&rz$is_dataframe_like..gs- P P4GC   P P P P P Pr()groupbyr?mergemeanc38K|]}t|VdSrr)rBrdfs r&rz$is_dataframe_like..hs-DDdD!!DDDDDDr()dtypesrc38K|]}t|VdSrrrFs r&rz$is_dataframe_like..is-EE4GC&&EEEEEEr(rr)rrr:rr)rKrts`@r&is_dataframe_likerO]s !67< t ,C P P P P+O P P PPP F DDDD.CDDD D D FEEEE3DEEEEE Er(cjtfddDo5tfddDodjvS)zLooks like a Pandas Seriesc38K|]}t|VdSrrrFs r&rz!is_series_like..qs- G G4GC   G G G G G Gr()rGr?rIc38K|]}t|VdSrrrBrrs r&rz!is_series_like..rs-??T4  ??????r()rrrrrr:lowerrrts`@r&is_series_likerWmsr +C G G G G+F G G GGG 0 ????->??? ? ? 0 3<--// /r(c~j}tfddDod|jvS)zLooks like a Pandas Indexc38K|]}t|VdSrrrSs r&rz is_index_like..{s- ; ;GAt   ; ; ; ; ; ;r(rNrrTrVs` r& is_index_likerZwsK +C ; ; ; ;): ; ; ;;; , s|))++ +r(c>dtt|vS)Ncupy)rer)rs r& is_cupy_typer]s Sa\\ !!r(list[str | int]c@dtjd|DS)a Sorting `key` function for performing a natural sort on a collection of strings See https://en.wikipedia.org/wiki/Natural_sort_order Parameters ---------- s : str A string that is an element of the collection being sorted Returns ------- tuple[str or int] Tuple of the parts of the input string where each part is either a string or an integer Examples -------- >>> a = ['f0', 'f1', 'f2', 'f8', 'f9', 'f10', 'f11', 'f19', 'f20', 'f21'] >>> sorted(a) ['f0', 'f1', 'f10', 'f11', 'f19', 'f2', 'f20', 'f21', 'f8', 'f9'] >>> sorted(a, key=natural_sort_key) ['f0', 'f1', 'f2', 'f8', 'f9', 'f10', 'f11', 'f19', 'f20', 'f21'] cXg|]'}|rt|n|(Sr")isdigitr)rBparts r&rDz$natural_sort_key..s/ T T Td 1CIIIT T T Tr(z(\d+))r6rrs r&natural_sort_keyrds&4 U TbhxQR>S>S T T TTr( float | strct|ttfrt|S|dd}t d|Dsd|z}t t |dz ddD]}||sn|dz}|d|}||d} t|}n%#t$r}td|z|d}~wwxYw t| }n%#t$r}td |z|d}~wwxYw||z}t|S) a\Parse byte string to numbers >>> from dask.utils import parse_bytes >>> parse_bytes('100') 100 >>> parse_bytes('100 MB') 100000000 >>> parse_bytes('100M') 100000000 >>> parse_bytes('5kB') 5000 >>> parse_bytes('5.4 kB') 5400 >>> parse_bytes('1kiB') 1024 >>> parse_bytes('1e6') 1000000 >>> parse_bytes('1e6 kB') 1000000000 >>> parse_bytes('MB') 1000000 >>> parse_bytes(123) 123 >>> parse_bytes('5 foos') Traceback (most recent call last): ... ValueError: Could not interpret 'foos' as a byte unit r2r\c3>K|]}|VdSr)ra)rBchars r&rzparse_bytes..s*,,$t||~~,,,,,,r(1rKrNz$Could not interpret '%s' as a numberz'Could not interpret '%s' as a byte unit) rErrr+rr(risalpharR byte_sizesrUr) rrrprefixsuffixrNrZ multiplierrs r& parse_bytesros}:!c5\""1vv  #rA ,,!,,, , , !G 3q66A:r2 & &t||~~  E  EE vvYF uvvYFQ &MM QQQ?&HIIqPQT / TTTBVKLLRSST^F v;;s0:C C,C''C,0D D2D--D2ii@Biʚ;lJ)lI5@ rK) kBrrrPBKiBMiBGiBTiBPiBBr\c>i|]\}}||Sr")rUrBrvs r&r'r's& : : :tq!aggii : : :r(c2i|]\}}|d|v |d|S)rrr"r~s r&r'r's,PPPtq!QP3a<<1Q4<<>> from dask.utils import format_time >>> format_time(1) '1.00 s' >>> format_time(0.001234) '1.23 ms' >>> format_time(0.00012345) '123.45 us' >>> format_time(123.456) '123.46 s' >>> format_time(1234.567) '20m 34s' >>> format_time(12345.67) '3hr 25m' >>> format_time(123456.78) '34hr 17m' >>> format_time(1234567.89) '14d 6hr' izd hri <zhr rNiXzm rrKz%.2f sMbP?z%.2f msg@@z%.2f usg.A)r)rNrhrNrs r& format_timers*  D2   QX]"d* + +}}q}}}; DMM QX# $ $}}}}}7{{ BKK AF OO||q|||Avv!|DyyAG$$ C  r(r cddddddd}tj|z }|D]@}t|||}|dkr|d kr |d d }|d |d cSAdS)aCalculate a '3 hours ago' type string from a Python datetime. Examples -------- >>> from datetime import datetime, timedelta >>> now = datetime.now() >>> format_time_ago(now) 'Just now' >>> past = datetime.now() - timedelta(minutes=1) >>> format_time_ago(past) '1 minute ago' >>> past = datetime.now() - timedelta(minutes=2) >>> format_time_ago(past) '2 minutes ago' >>> past = datetime.now() - timedelta(hours=1) >>> format_time_ago(past) '1 hour ago' >>> past = datetime.now() - timedelta(hours=6) >>> format_time_ago(past) '6 hours ago' >>> past = datetime.now() - timedelta(days=1) >>> format_time_ago(past) '1 day ago' >>> past = datetime.now() - timedelta(days=5) >>> format_time_ago(past) '5 days ago' >>> past = datetime.now() - timedelta(days=8) >>> format_time_ago(past) '1 week ago' >>> past = datetime.now() - timedelta(days=16) >>> format_time_ago(past) '2 weeks ago' >>> past = datetime.now() - timedelta(days=190) >>> format_time_ago(past) '6 months ago' >>> past = datetime.now() - timedelta(days=800) >>> format_time_ago(past) '2 years ago' c|jdz S)Nimdaysdiffs r&z!format_time_ago..Ks di#or(c|jdz S)Ngp= o>@rrs r&rz!format_time_ago..Ls ty94r(c|jdz S)Nrrs r&rz!format_time_ago..Ms di!mr(c|jSrrrs r&rz!format_time_ago..NsTYr(c|jdz S)Nrsecondsrs r&rz!format_time_ago..Os dlT1r(c|jdzdz S)Nrrrrs r&rz!format_time_ago..Ps t 3b 8r()yearsmonthsweeksrhoursminutesrrKNrr2z agozJust now)r nowr)rNunitsrunitdurs r&format_time_agorsj.-44++&&1188   E <>>A D''+%+d##$$ 77axxCRCy&&D&&& & & &  :r(cJdD]\}}||dzkr||z dd|dcS|dS)aFormat bytes as text >>> from dask.utils import format_bytes >>> format_bytes(1) '1 B' >>> format_bytes(1234) '1.21 kiB' >>> format_bytes(12345678) '11.77 MiB' >>> format_bytes(1234567890) '1.15 GiB' >>> format_bytes(1234567890000) '1.12 TiB' >>> format_bytes(1234567890000000) '1.10 PiB' For all values < 2**60, the output is always <= 10 characters. ))Pirt)Tirs)Girr)Mirq)kirpg?z.2fr2r|z Br")rNrlrs r& format_bytesr\sZ&,,  C<<!e+++&+++ + + + 888Or(rgư>g& .>rriQi: )rmsusnsrNrrrv)secondminutehourdayweek millisecond microsecond nanosecondc i|] \}}|dz| Srcr"r~s r&r'r's" 1 1 1DAqQWa 1 1 1r(c>i|]\}}||Sr")upperr~s r&r'r's&IIIA 1IIIr(rdefaultstr | Literal[False]cdSrr"rrs r&parse_timedeltarsCr(str | float | timedeltacdSrr"rs r&rrs Cr(c4|dSt|tr8|}t||krt|n|St|trt |}|dd}|dsd|z}tt|dz ddD]}|| sn|dz}|d|}||dp|}|durtd |t|t std |t|}t|}||z}t||krt|}|S) afParse timedelta string to number of seconds Parameters ---------- s : str, float, timedelta, or None default: str or False, optional Unit of measure if s does not specify one. Defaults to seconds. Set to False to require s to explicitly specify its own unit. Examples -------- >>> from datetime import timedelta >>> from dask.utils import parse_timedelta >>> parse_timedelta('3s') 3 >>> parse_timedelta('3.5 seconds') 3.5 >>> parse_timedelta('300ms') 0.3 >>> parse_timedelta(timedelta(seconds=3)) # also supports timedeltas 3 Nr2r\rrirKrFzMissing time unit: z"default must be str or False, got )rEr total_secondsrrrer+rar(rrjrRrrtimedelta_sizesrU) rrrrrlrmrNrnrs r&rrs. yt!Y, OO  Q1s1vvv!+!V FF #rA Q4<<>> !G 3q66A:r2 & &t||~~  E  EE vvYF uvvY !'F 2q22333 fc " "JHWHHIII f A 0J ^F 6{{fV Mr(c\ |tj|jvS#t$rYdSwxYw)NF)rrrr)r#keywords r& has_keywordrsB'+D11<<< uus  ++cvt|ttfsdS|sdSdt|dzSrJ)rErFrndimlistrs r&rrsA cD%= ) )$q $q8CF####r(c#Kgd}}t|}t|d}|J||ksJ||z|kr+||||z }t|d}n |sJ|Vgd}}|J|r|VdSdS)a Split sizes into chunks of total max_size each Parameters ---------- sizes : iterable of numbers The sizes to be chunked max_size : number Maximum total size per chunk. It must be greater or equal than each size in sizes rN)iternextappend)sizesmax_sizechunk chunk_sum iter_sizessizes r& iter_chunksrs19EeJ  D ! !D  x t x ' ' LL     I D))DDLLLKKK!19E    r(z[a-f]+icDt|tur|}t|tur|d} |d}|dds5|dddd}n|d}|ddD]L}|r6t|dkrt | |d|zz }Lt|dkrtj d |rd S|dd krF|d dd d}|S#t$rYdSwxYw)aw >>> key_split('x') 'x' >>> key_split('x-1') 'x' >>> key_split('x-1-2-3') 'x' >>> key_split(('x-2', 1)) 'x' >>> key_split("('x-2', 1)") 'x' >>> key_split("('x', 1)") 'x' >>> key_split('hello-world-1') 'hello-world' >>> key_split(b'hello-world-1') 'hello-world' >>> key_split('ae05086432ca935f6eba409a8ecd4896') 'data' >>> key_split('>> key_split(None) 'Other' >>> key_split('x-abcdefab') # ignores hex 'x' >>> key_split('_(x)') # strips unpleasant characters 'x' rr$,z_'()"rKN z [a-f0-9]{32}rrz<>r^rOther) rrrrrrjrr hex_patternr7r6r)rwordsrwords r& key_splitrs< Aww% HHJJ Aww% aD Qx{""$$ 1X^^C((+11(;;FF1XF!""I  D||~~ D Q;#4#4T#:#:#F#*$ v;;"  /6!B!B 6ayCd++1133A6<>> stringify(b'x') b'x' >>> stringify('x') 'x' >>> stringify({('a',0):('a',0), ('a',1): ('a',1)}) "{('a', 0): ('a', 0), ('a', 1): ('a', 1)}" >>> stringify({('a',0):('a',0), ('a',1): ('a',1)}, exclusive={('a',0)}) {('a', 0): "('a', 0)", ('a', 1): ('a', 1)} Nr)SubgraphCallablec38K|]}t|VdSr stringifyrBrrs r&rzstringify..vs-??!i9--??????r(rKc38K|]}t|VdSrrrs r&rzstringify..xs-"L"Lq9Q #:#:"L"L"L"L"L"Lr(c0g|]}t|Sr"rrBrrs r&rDzstringify..{s#555A !Y''555r(c8i|]\}}|t|Sr"r)rBrrrs r&r'zstringify..}s)CCCtq!9Q **CCCr(c38K|]}t|VdSrrrs r&rzstringify..s-::Yq),,::::::r()rrerrdask.optimizationrrroutkeyinkeysrcallablerFr rCr)rWrrtrobj0s ` r&rrAsD s))C czzSE\\  3xx e|||6666661v ::) ) )D  dh 22Kdk955I ????s122w?????@ @d^^ M7U"L"L"L"LCG"L"L"LLLL L d{{55555555 d{{CCCCsyy{{CCCC )  S>> !        e||::::c:::::: Js<E EEct|}|tury|rw|d}t|tust|turt |St |r%|ftd|ddDzS|t ur d|DS|turd|DS|turtd|DS|S)zConvert all collection keys in ``obj`` to strings. This is a specialized version of ``stringify()`` that only converts keys of the form: ``("a string", ...)`` rc34K|]}t|VdSrstringify_collection_keysrs r&rz,stringify_collection_keys..s+"Q"QA#.s!:::)!,,:::r(c4i|]\}}|t|Sr"rr~s r&r'z-stringify_collection_keys..s'HHHDAq,Q//HHHr(c34K|]}t|VdSrrrs r&rz,stringify_collection_keys..s+??a.q11??????r() rrrerrrrFr rC)rWrtrs r&rrs s))C e|||1v ::  T e 3 3S>> ! D>> R7U"Q"QQRR"Q"Q"QQQQ Q d{{::c:::: d{{HHCIIKKHHHH e||??3?????? Jr(ceZdZdZdZdS)cached_propertyz/Read only version of functools.cached_property.c td)z8Raise an error when attempting to set a cached property.zCan't set attribute)rz)rinstancers r&__set__zcached_property.__set__s2333r(N)r:rrrrr"r(r&rrs)9944444r(rc*eZdZdZdZdZdZdZdS)_HashIdWrapperz>Hash and compare a wrapped object by identity instead of valuec||_dSr)rb)rrbs r&rz_HashIdWrapper.__init__s  r(cVt|tstS|j|juSrrErNotImplementedrbrs r&rz_HashIdWrapper.__eq__s)%00 "! !|u},,r(cVt|tstS|j|juSrrrs r&__ne__z_HashIdWrapper.__ne__s)%00 "! !|5=00r(c*t|jSr)rrbrs r&__hash__z_HashIdWrapper.__hash__s$,r(N)r:rrrrrrrr"r(r&rrsVHH--- 111      r(rct|tr|j}|r(tt jt |dStt jt |S)Nr)rErrbrrh accumulater)rM initial_zeros r&_cumsumrs[#~&&k1U%c322333U%c3//000r(ct|trtt||}ntt||}|S)aCompute :meth:`toolz.accumulate` with caching. Caching is by the identify of `seq` rather than the value. It is thus important that `seq` is a tuple of immutable objects, and this function is intended for use where `seq` is a value that will persist (generally block sizes). Parameters ---------- seq : tuple Values to cumulatively sum. initial_zero : bool, optional If true, the return value is prefixed with a zero. Returns ------- tuple )rErrr)rMrrs r& cached_cumsumr sM&#u3,,l;;s\22 Mr(cddlm}m}ddlm}ddlm}ddlm}m } ddl m }n#t$rd}YnwxYwddl m }gd}d d |dd D|j||d } |D]!} || | | <#|$rd| | <YwxYw||| d dS)z,Provide version information for bug reports.r)PackageNotFoundErrorr))dumps)uname)stdout version_info) __version__N)rpandas cloudpicklefsspecbokeh fastparquetpyarrowzarrr^c,g|]}t|Sr"rrs r&rDz!show_versions..s===qCFF===r()PythonPlatformr distributedr4)rA)importlib.metadatar r)jsonr platformr sysrrrrrVrrsystem writelines) r r)r r rrdistributed_version dask_versionrrmodnames r& show_versionsr&sA@@@@@@@((((((((#BBBBBBB ###"#100000   D((==L!,<===>>EGGN* %%F## #%gg..F7OO# # # #"F7OOO # eeF1---... Fs% 44?B BBc4|dkr|d|S|d|p|dzS)z4Pluralize a count-noun string pattern when necessaryrKr2rr")countnoun plural_forms r&maybe_pluralizer+s< zz  $   55+3555r(rWct|toOt|do?t|do/t|dot|dot|dS)zReturns True if obj is an instance of a namedtuple. Note: This function checks for the existence of the methods and attributes that make up the namedtuple API, so it will return True IFF obj's type implements that API. _make_asdict_replace_fields_field_defaults)rErr)rWs r&is_namedtuple_instancer2sw 3 , C ! ! , C # # , C $ $ , C # #  , C* + + r(ctjddx}r|S ddlm}|tjds# ddlm}|dS#t$rYnwxYwdS#ttf$rYdSwxYw) Nzdataframe.shuffle.methodr)default_clientzoptimization.fuse.active)check_minimal_arrow_versionp2ptasksdisk) rrrr4rdistributed.shuffler5rWrVrR)rr4r5s r&get_default_shuffle_algorithmr:(s J14 8 88q......{9::  KKKKKK++---u    w  $vvs//A/ A A*'A/)A**A//BBct|dr|j}tt|ddS)N_metar^r)rr<rrxr)likes r&get_meta_libraryr>=sBtWz $11#66q9 : ::r(r) r)r.r*r.r+r.r,r.r-r/)r\N)rNr)rNrrrF)rr)T)rr)rr)r\rN)Nr\rN)NNrNrr6)rtrrurrre)rr)NN)rr r rrr )rrr rrr)rrerr^)rrerr)rNrrre)rNr rre)rNrrrer)rrrrrr)rrrrrr)rr)rWrrr) __future__rrr;rrdr6rkr rbrr6collections.abcrrrrr contextlibr r r r r rrr importlibrnumbersrroperatorr threadingrtypingrrrrrweakrefrtlzrhrr dask.corerrrrgetdefaultencodingsystem_encodingr' FutureWarningr>rArPrLr[rprur|r~rrrrrrrrr rrr r bytearrayrrchrr7complexr r`revalrr4 frozensethashhexrrrrrFrminroctordr(reprreversedroundr)slicer* staticmethodresumrrvarsrG memoryviewrcompiledelattrdivmodfilterrrrE issubclassrpowr,rrrrrrrr r0rErIr[rdrorxr~rrrrrrrrrrprrMrrrrrr;rCrOrWrZr]rdrorkrCrrrrrtds2rrrrrrrrrrrr r&r+r2r:r>r"r(r&rgsN """""""   FFFFFFFFFFFFFF<<<<<<<<<<((((((((######$$$$$$$$<<<<<<<<<<<<<<''''''  GCLL GCLL GCLL)#(**gO""""N $"+ <<<<<<~"  " " "&---)()()()(X''''Bd     ( ( ( ( (F   6     0 P P P P//// /  /  / / /// / /// /  !/" #/$%/& '/()/*+/,-/. //01/2 3/45/67/8 9/:;/< =/>?/@ A/B C/D E/F G/HI/J K/L M/NO/PQ/RS/T U/V W/X Y/Z[/\]/b         , , ,,;,;,;,;^H<H<H<H<H<H<H<H