LgtUddlmZddlZddlZddlZddlZddlmZddlm Z m Z m Z ddl m Z ddlmZmZddlmZddlmZdd lmZmZdd lmZdd lmZmZmZdd lmZm Z dd l!m"Z"m#Z#ddl$m%Z%ddl&m'Z'ddl&m(Z)ddl&m*Z*ddl+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5da6da7da8dCdZ9dZ:ddl;mZ>eddZ?de@d<dDdZAedEdZBdCdZCGdd ZDdFd!ZEd"ZFd#ZGdGd%ZHd&ZId$d'd(ZJd$d'd)ZKd$d$ddd*d+ZLd,d$d-ddd. dHd/ZM dI dHd0ZNd$d$dd1d2ZOd3ZPe#je#je#jd4ZRd5e@d6<e%s\dd7l!mSZSeRjeSjPeSjPd8dd9l!mUZVeRjeVjPeVjPd:d;jZXdJd<ZYdKd=ZZdLd>Z[dMd?Z\ed@e.e]Z^dNdAZ_dOdBZ`y)P) annotationsN) OrderedDict)HashableIteratorMapping)Executor)contextmanagersuppress) ContextVar)partial)IntegralNumber)getitem)AnyLiteralTypeVar)groupbymerge)configlocal) EMSCRIPTEN)flatten)get)quote) CPU_COUNT)KeySchedulerGetCallable)apply ensure_dictis_namedtuple_instance key_splitshorten_tracebackcpttS ddlmaddlmadatS#t$r daYtSwxYw)Nr)Client get_clientTF)_DISTRIBUTED_AVAILABLE distributedr$_DistributedClientdistributed.workerr&_get_distributed_client ImportError)lib/python3.12/site-packages/dask/base.py_distributed_availabler0'sF)%%'<L!% "! '!& !!'s " 55)DaskMethodsMixinannotateget_annotationsis_dask_collectioncomputepersistoptimize visualizetokenizenormalize_tokenget_collection_namesget_name_from_keyreplace_name_in_key clone_key)TokenizationErrorr:r9r)defaultz!ContextVar[dict[str, Any] | None] _annotationsc2tjxsiS)zGet current annotations. Returns ------- Dict of all current annotations See Also -------- annotate )rArr-r.r/r3r3Os     ##r.c+tKd|vrmt|dtttfrt|d|d<n=t|dtr |dg|d<n t |drnt d|dzd|vr2t|dtst |dst d|dzd|vr2t|dtst |dst d|dzd|vr2t|dtst |dst d|dzd |vr2t|d tst |d st d |d ztj}|i}tjt||} d tj|y #tj|wxYww) aContext Manager for setting HighLevelGraph Layer annotations. Annotations are metadata or soft constraints associated with tasks that dask schedulers may choose to respect: They signal intent without enforcing hard constraints. As such, they are primarily designed for use with the distributed scheduler. Almost any object can serve as an annotation, but small Python objects are preferred, while large objects such as NumPy arrays are discouraged. Callables supplied as an annotation should take a single *key* argument and produce the appropriate annotation. Individual task keys in the annotated collection are supplied to the callable. Parameters ---------- **annotations : key-value pairs Examples -------- All tasks within array A should have priority 100 and be retried 3 times on failure. >>> import dask >>> import dask.array as da >>> with dask.annotate(priority=100, retries=3): ... A = da.ones((10000, 10000)) Prioritise tasks within Array A on flattened block ID. >>> nblocks = (10, 10) >>> with dask.annotate(priority=lambda k: k[1]*nblocks[1] + k[2]): ... A = da.ones((1000, 1000), chunks=(100, 100)) Annotations may be nested. >>> with dask.annotate(priority=1): ... with dask.annotate(retries=3): ... A = da.ones((1000, 1000)) ... B = A + 1 See Also -------- get_annotations workerszP'workers' annotation must be a sequence of str, a str or a callable, but got %s.priorityz@'priority' annotation must be a Number or a callable, but got %sretriesz?'retries' annotation must be a Number or a callable, but got %s resourcesz1'resources' annotation must be a dict, but got %sallow_other_workerszJ'allow_other_workers' annotations must be a bool or a callable, but got %sN) isinstancelistsettuplestrcallable TypeErrorrdictboolrArrreset)r ctx_annottokens r/r2r2]sfK k),tS%.@ A%)+i*@%AK "  I. 4&1)&<%=K " k), - bi()  k!;z2F;Z01 N*% &  [ ;y16:Y/0 M)$ %  {";{3T:[12 ?+& '  ,;'<=tD%:;< X/0 1    "I   U9k: ;E" 5! 5!sFF8FF8F55F8ct|ts!t|drt|jsyt t|ddj dd}|dvry|j d uS) aReturns ``True`` if ``x`` is a dask collection. Parameters ---------- x : Any Object to test. Returns ------- result : bool ``True`` if `x` is a Dask collection. Notes ----- The DaskCollection typing.Protocol implementation defines a Dask collection as a class that returns a Mapping from the ``__dask_graph__`` method. This helper function existed before the implementation of the protocol. __dask_graph__F __module__.r) dask_expr dask_cudfTN)rItypehasattrrNrVgetattrsplit)xpkg_names r/r4r4sp, 1dq*+(()tAw b177>> x.visualize(filename='dask.pdf') # doctest: +SKIP >>> x.visualize(filename='dask.pdf', color='order') # doctest: +SKIP Returns ------- result : IPython.display.Image, IPython.display.SVG, or None See dask.dot.dot_graph for more information. See Also -------- dask.visualize dask.dot.dot_graph Notes ----- For more information on optimization see here: https://docs.dask.org/en/latest/optimize.html )filenameformatoptimize_graph)r8)selfrerfrgkwargss r/r8zDaskMethodsMixin.visualizes-X  )     r.c &t|fddi|\}|S)aPersist this dask collection into memory This turns a lazy Dask collection into a Dask collection with the same metadata, but now with the results fully computed or actively computing in the background. The action of function differs significantly depending on the active task scheduler. If the task scheduler supports asynchronous computing, such as is the case of the dask.distributed scheduler, then persist will return *immediately* and the return value's task graph will contain Dask Future objects. However if the task scheduler only supports blocking computation then the call to persist will *block* and the return value's task graph will contain concrete Python results. This function is particularly useful when using distributed systems, because the results will be kept in distributed memory, rather than returned to the local process as with compute. Parameters ---------- scheduler : string, optional Which scheduler to use like "threads", "synchronous" or "processes". If not provided, the default is to check the global settings first, and then fall back to the collection defaults. optimize_graph : bool, optional If True [default], the graph is optimized before computation. Otherwise the graph is run as is. This can be useful for debugging. **kwargs Extra keywords to forward to the scheduler function. Returns ------- New dask collections backed by in-memory data See Also -------- dask.persist traverseF)r6rhriresults r/r6zDaskMethodsMixin.persist2s ND;5;F;  r.c &t|fddi|\}|S)aCompute this dask collection This turns a lazy Dask collection into its in-memory equivalent. For example a Dask array turns into a NumPy array and a Dask dataframe turns into a Pandas dataframe. The entire dataset must fit into memory before calling this operation. Parameters ---------- scheduler : string, optional Which scheduler to use like "threads", "synchronous" or "processes". If not provided, the default is to check the global settings first, and then fall back to the collection defaults. optimize_graph : bool, optional If True [default], the graph is optimized before computation. Otherwise the graph is run as is. This can be useful for debugging. kwargs Extra keywords to forward to the scheduler function. See Also -------- dask.compute rkF)r5rls r/r5zDaskMethodsMixin.compute\s0D;5;F;  r.c ddlmmfd}|j S#t$r}td|d}~wwxYw)Nr) futures_ofwaitz>Using async/await with dask requires the `distributed` packagecDKrd{S7wNr-)rprhrqsr/fz%DaskMethodsMixin.__await__..fs&$4j  K!s   )r(rprqr, __await__)rhertrprqs` @@r/ruzDaskMethodsMixin.__await__wsE  4   s}} P  s) A >A)mydaskNF) __name__rW __qualname____doc__ __slots__r8r6r5rur-r.r/r1r1s 9 I2 h(T6 r.r1c Xt|||}t|||fi|}|||fi|S)zqCompute a graph as if it were of type cls. Allows for applying the same optimizations and default scheduler.) schedulerclsr) get_scheduleroptimization_function)r~dskkeysr}rrischeduledsk2s r/compute_as_if_collectionrs=ycsCH %  %c4 :6 :D D$ )& ))r.c |Srsr-)rrris r/ dont_optimizers Jr.c$t|dtS)N__dask_optimize__)r^r)r`s r/rrs 1)= 99r.Tc  ddlm t|ttjddz}|rt t |}g}|jD]?\}}t|\}} ||| fi|}|D] } | || fi|}|j|At fd|Dr j|}|Sttt|}|St|\}} |S)zO Convert many collections into a single dask graph, after optimization rHighLevelGraph optimizationsr-c36K|]}t|ywrsrI.0graphrs r/ z%collections_to_dsk..sEfUz%0f)dask.highlevelgraphrrLrrrritems_extract_graph_and_keysappendanyrmapr) collectionsrgrrigroupsgraphsoptvalrr opt_inner_rs @r/collections_to_dskrs3-(5OR1P+QQM. < HC/4ICc4*6*C* T4V4+ MM# ' EfE E&.&&/C J [&12C J)5Q Jr.c$ddlmgg}}|D]@}|j|j|j|j Bt fd|Drj |}||fSt tt|}||fS)zGiven a list of dask vals, return a single graph and a list of keys such that ``get(dsk, keys)`` is equivalent to ``[v.compute() for v in vals]``.rrc36K|]}t|ywrsrrs r/rz*_extract_graph_and_keys..s A&:e^ ,&r) rrrrV __dask_keys__rrrr)valsrrvrrs @r/rrs3rDF  a&&() AOO%& A& AA$$$f- $;s;/0 $;r.)rkc4 gi tjj fdtjjt|Dcgc] }| c}f < fd}t }j ||fScc}w)aExtract collections in preparation for compute/persist/etc... Intended use is to find all collections in a set of (possibly nested) python objects, do something to them (compute, etc...), then repackage them in equivalent python objects. Parameters ---------- *args Any number of objects. If it is a dask collection, it's extracted and added to the list of collections returned. By default, python builtin collections are also traversed to look for dask collections (for more information see the ``traverse`` keyword). traverse : bool, optional If True (default), builtin python collections are traversed looking for any dask collections they might contain. Returns ------- collections : list A list of all dask collections contained in ``args`` repack : callable A function to call on the transformed collections to repackage them as they were in the original ``args``. ct|r7t|}| vr&t t f |< j ||St j j} s t|}n4t|trtn t|}|tttfvr||Dcgc] }| c}f}n|tt fvr4||j#Dcgc]\}}||gc}}f}nt%j&|rht|tsXt(|dtt%j*|Dcgc]*}|j,t/||j,g,c}ff}n(t1|r|g|Dcgc] }| c}}n|S| |<|Scc}wcc}}wcc}wcc}w)Nr-)r4r9rlenruuiduuid4hexrrIrrJr\rLrKrPrr dataclasses is_dataclassrfieldsnamer^r ) exprtoktsktypikrrt_unpackrcollections_token repack_dskrks r/rz#unpack_collections.._unpacks d #4.C*$#*,=s;?O"P 3""4(Jjjl+C%T84$$t*CtUC((6AWQZ67{++$**,O,$!Qgaj'!*5,OP))$/ 48N&1%7%7%=%=VVWWT166-B%CD%= (-8$7$Qgaj$78  3 -7O8s*F, F1/F7 F<cXj}t||<t|Srs)copyr simple_get)resultsrroutrs r/repackz"unpack_collections..repacks+oo!&w #s##r.)rrrrLrJclear) rkargsrr collections2rrrrrs ` @@@@@r/unpack_collectionsrs6KJ ((%%N **,  C484awqz489JsO$ $L  9sBct|d|i\}}|s|St|fi|}g}|D]-}|j\}} |j||g| /||S)aOptimize several dask collections at once. Returns equivalent dask collections that all share the same merged and optimized underlying graph. This can be useful if converting multiple collections to delayed objects, or to manually apply the optimizations at strategic points. Note that in most cases you shouldn't need to call this method directly. Parameters ---------- *args : objects Any number of objects. If a dask object, its graph is optimized and merged with all those of all other dask objects before returning an equivalent dask collection. Non-dask arguments are passed through unchanged. traverse : bool, optional By default dask traverses builtin python collections looking for dask objects passed to ``optimize``. For large collections this can be expensive. If none of the arguments contain any dask objects, set ``traverse=False`` to avoid doing this traversal. optimizations : list of callables, optional Additional optimization passes to perform. **kwargs Extra keyword arguments to forward to the optimization passes. Examples -------- >>> import dask >>> import dask.array as da >>> a = da.arange(10, chunks=2).sum() >>> b = da.arange(10, chunks=2).mean() >>> a2, b2 = dask.optimize(a, b) >>> a2.compute() == a.compute() np.True_ >>> b2.compute() == b.compute() np.True_ rk)rr__dask_postpersist__r) rkrrirrr postpersistsarss r/r7r7 stP-dFXFK  [ 3F 3CL %%'1AcJAJ' , r.)rkrgr}rc t|d|i\}}|s|St|||}t||fi|} gg} } |D]@} | j| j | j| j Bt 5|| | fi|} ddd|t | Dcgc]\}\}}||g|c}}}S#1swY:xYwcc}}}w)aCompute several dask collections at once. Parameters ---------- args : object Any number of objects. If it is a dask object, it's computed and the result is returned. By default, python builtin collections are also traversed to look for dask objects (for more information see the ``traverse`` keyword). Non-dask arguments are passed through unchanged. traverse : bool, optional By default dask traverses builtin python collections looking for dask objects passed to ``compute``. For large collections this can be expensive. If none of the arguments contain any dask objects, set ``traverse=False`` to avoid doing this traversal. scheduler : string, optional Which scheduler to use like "threads", "synchronous" or "processes". If not provided, the default is to check the global settings first, and then fall back to the collection defaults. optimize_graph : bool, optional If True [default], the optimizations for each collection are applied before computation. Otherwise the graph is run as is. This can be useful for debugging. get : ``None`` Should be left to ``None`` The get= keyword has been removed. kwargs Extra keywords to forward to the scheduler function. Examples -------- >>> import dask >>> import dask.array as da >>> a = da.arange(10, chunks=2).sum() >>> b = da.arange(10, chunks=2).mean() >>> dask.compute(a, b) (np.int64(45), np.float64(4.5)) By default, dask objects inside python collections will also be computed: >>> dask.compute({'a': a, 'b': b, 'c': 1}) ({'a': np.int64(45), 'b': np.float64(4.5), 'c': 1},) rk)r}rrN)rrrrr__dask_postcompute__r"zip)rkrgr}rrrirrrrr postcomputesr`rrrtrs r/r5r5VsZ-dFXFK   H [. CF CCR,D  AOO%&A2245  3//  S,-GH-G 6Aq1Q88-GH II  Is C&C CrwF)rerkrgmaxvalenginec nt|d|i\}}tt||}td||||||d|S)a Visualize several dask graphs simultaneously. Requires ``graphviz`` to be installed. All options that are not the dask graph(s) should be passed as keyword arguments. Parameters ---------- args : object Any number of objects. If it is a dask collection (for example, a dask DataFrame, Array, Bag, or Delayed), its associated graph will be included in the output of visualize. By default, python builtin collections are also traversed to look for dask objects (for more information see the ``traverse`` keyword). Arguments lacking an associated graph will be ignored. filename : str or None, optional The name of the file to write to disk. If the provided `filename` doesn't include an extension, '.png' will be used by default. If `filename` is None, no file will be written, and we communicate with dot using only pipes. format : {'png', 'pdf', 'dot', 'svg', 'jpeg', 'jpg'}, optional Format in which to write output file. Default is 'png'. traverse : bool, optional By default, dask traverses builtin python collections looking for dask objects passed to ``visualize``. For large collections this can be expensive. If none of the arguments contain any dask objects, set ``traverse=False`` to avoid doing this traversal. optimize_graph : bool, optional If True, the graph is optimized before rendering. Otherwise, the graph is displayed as is. Default is False. color : {None, 'order', 'ages', 'freed', 'memoryincreases', 'memorydecreases', 'memorypressure'}, optional Options to color nodes. colormap: - None, the default, no colors. - 'order', colors the nodes' border based on the order they appear in the graph. - 'ages', how long the data of a node is held. - 'freed', the number of dependencies released after running a node. - 'memoryincreases', how many more outputs are held after the lifetime of a node. Large values may indicate nodes that should have run later. - 'memorydecreases', how many fewer outputs are held after the lifetime of a node. Large values may indicate nodes that should have run sooner. - 'memorypressure', the number of data held when the node is run (circle), or the data is released (rectangle). maxval : {int, float}, optional Maximum value for colormap to normalize form 0 to 1.0. Default is ``None`` will make it the max number of values collapse_outputs : bool, optional Whether to collapse output boxes, which often have empty labels. Default is False. verbose : bool, optional Whether to label output and input boxes even if the data aren't chunked. Beware: these labels can get very long. Default is False. engine : {"graphviz", "ipycytoscape", "cytoscape"}, optional. The visualization engine to use. If not provided, this checks the dask config value "visualization.engine". If that is not set, it tries to import ``graphviz`` and ``ipycytoscape``, using the first one to succeed. **kwargs Additional keyword arguments to forward to the visualization engine. Examples -------- >>> x.visualize(filename='dask.pdf') # doctest: +SKIP >>> x.visualize(filename='dask.pdf', color='order') # doctest: +SKIP Returns ------- result : IPython.display.Image, IPython.display.SVG, or None See dask.dot.dot_graph for more information. See Also -------- dask.dot.dot_graph Notes ----- For more information on optimization see here: https://docs.dask.org/en/latest/optimize.html rk)rg)rrerkrgrrr-)rrPr visualize_dsk) rerkrgrrrrirrs r/r8r8sXp!$::GD! !$~F GC   %    r.c  |jd} ddlm} m} | dvr*ddlm} 9| |d} | j Dcic]\}}||jc}}nktttjtr | |d} n0} j Dcic]\}}||jc}} |jd}t|t"rddlm} t%| j|}fd}d}| d k7r| |d}| j'd r0|j Dcic]\}}||j(c}}n| j'd r0|j Dcic]\}}||j*c}}nk| j'd r\|j Dcic]\}}||j,c}}|j Dcic]\}}||j.}}}n| j'd rF|j Dcic])\}}|t1d|j.|j,z +c}}n| j'drF|j Dcic])\}}|t1d|j,|j.z +c}}nP| j3dddvr/| j Dcic]\}}||j4c}}n t7| | j9dr fd}n|#t1dt1j}j Dcic]3\}}|t;t=t?t|||z d5}}}||}nNj Dcic]3\}}|t;t=t?t|||z d5}}}|j Dcic]\}}||||dc}}|d<|j Dcic] \}}|d|i c}}|d<n| rt7d| z|xstAjdd}|s ddl!}d}|dk(rddl$m%}||fd|i|S|dvrdd l$m&}||fd|i|S| tOd!tQd"|d#cc}}wcc}}w#t$r| jj }YwxYwcc}}wcc}}wcc}}wcc}}wcc}}wcc}}wcc}}wcc}}wcc}}wcc}}wcc}}w#tD$r ddl#}d}n#tD$rYnwxYwYwxYw)$Ncolorr) diagnosticsorder> order-age order-freedorder-memorypressureorder-memorydecreasesorder-memoryincreasesagecpathfreedrcriticalmemorypressurememorydecreasesmemoryincreasesT) return_statscmapc t|SrsrM)r`valuess r/labelzvisualize_dsk..label1svay> !r.rrrrrr->rrzorder-cDt|dzt|zS)Nrr)r`ors r/rzvisualize_dsk..labelQs"qt9s?S^;;r.)bytes)rrfunction_attributesdata_attributeszUnknown value color=%szvisualization.enginegraphviz cytoscape) dot_graphre)r ipycytoscape)cytoscape_graphzINo visualization engine detected, please install graphviz or ipycytoscapezVisualization engine z not recognized))r dask.orderrrmatplotlib.pyplotpyplotrrErInextiterrintpopKeyErrorcmplasmarMr^endswithrnum_dependencies_freednum_data_when_runnum_data_when_releasedmaxr_ critical_pathNotImplementedError startswith _colorizerLrrrr,rdask.dotrr RuntimeError ValueError)rrerkrgrrrlimitrirrrplto_statsrrrr data_valuesinfokeyrcolors data_colorsrrrrrs ` @r/rrsQ JJw E-  ( 9Cd3G+2==?;?41aAJJ?;A T!((*-. 4Cd3GG+,7795941aAJJ95A !::f%D dC +3664(D " G sA&q)D~~e$7;zz|D|83#sww,|D(JN**,W,hc3#s999,W 01EIZZ\R\c#s444\RDHJJLDPSC333L 12%)JJL$0SQ : :S=R=R RSS$0 12%)JJL$0SQ 5 58R8R RSS$0S!"%)>>AHQXS##s000Q)%00)<F >C 01F  &1 ys3QZt(DEFG G&     K#LLN*DAq9U3sDV4,H#IJKK*  ) ;I41aAU1X. .>) $%BMARARAT$UATAQ! _AT$U ! !":U"BCC ?vzz"8$?F   F&:x:6:: 0 0,s@X@@@  W  0HIIO< 6 !66==D !EWR  R  ) %V  #$    sS2S SS7 S= T8T 7.T.T*T#8T!68T'T-4T38T9S43S49 UU  U UUUUU)rkrgr}c t|d|i\}}|s|St||}tj|r; ddlm} |} | j |k(r| j|fd|i|} || St||fi|} gg} } |D]\}tt|j}|j\}}| j|| j!|||f^t#5|| | fi|} dddt%t'|  }| Dcgc]!\}}}||Dcic]}||| c}g|#}}}}}||S#t$rYwxYw#t$rYwxYw#1swYvxYwcc}wcc}}}}w)aQ Persist multiple Dask collections into memory This turns lazy Dask collections into Dask collections with the same metadata, but now with their results fully computed or actively computing in the background. For example a lazy dask.array built up from many lazy calls will now be a dask.array of the same shape, dtype, chunks, etc., but now with all of those previously lazy tasks either computed in memory as many small :class:`numpy.array` (in the single-machine case) or asynchronously running in the background on a cluster (in the distributed case). This function operates differently if a ``dask.distributed.Client`` exists and is connected to a distributed scheduler. In this case this function will return as soon as the task graph has been submitted to the cluster, but before the computations have completed. Computations will continue asynchronously in the background. When using this function with the single machine scheduler it blocks until the computations have finished. When using Dask on a single machine you should ensure that the dataset fits entirely within memory. Examples -------- >>> df = dd.read_csv('/path/to/*.csv') # doctest: +SKIP >>> df = df[df.name == 'Alice'] # doctest: +SKIP >>> df['in-debt'] = df.balance < 0 # doctest: +SKIP >>> df = df.persist() # triggers computation # doctest: +SKIP >>> df.value().min() # future computations are now fast # doctest: +SKIP -10 >>> df.value().max() # doctest: +SKIP 100 >>> from dask import persist # use persist function on multiple collections >>> a, b = persist(a, b) # doctest: +SKIP Parameters ---------- *args: Dask collections scheduler : string, optional Which scheduler to use like "threads", "synchronous" or "processes". If not provided, the default is to check the global settings first, and then fall back to the collection defaults. traverse : bool, optional By default dask traverses builtin python collections looking for dask objects passed to ``persist``. For large collections this can be expensive. If none of the arguments contain any dask objects, set ``traverse=False`` to avoid doing this traversal. optimize_graph : bool, optional If True [default], the graph is optimized before computation. Otherwise the graph is run as is. This can be useful for debugging. **kwargs Extra keywords to forward to the scheduler function. Returns ------- New dask collections backed by in-memory data rk)r}rr)default_clientrgN)rrinspectismethoddistributed.clientrrr6r r,rrJrrrextendrr"rPr)rkrgr}rrirrrrclientrrrrra_keysrebuildstatedrksrrresults2s r/r6r6sx-dFXFK  ykJH! + 9 +')::),fnn#4BFLG"'?* [. CF CCR,D gaoo/01//1 FWfe45   3//  Sw  A=IJ\BB'Bq1ad7B',!,\HJ ( -      ,  (JsFEE, E,E= * E87 E=  EE E)(E),E58E= cddtfdtD}tt|ddj }ddt |z z|z}d|zS)zConvert (r, g, b) triple to "#RRGGBB" string For use with ``visualize(color=...)`` Examples -------- >>> _colorize((255, 255, 255)) '#FFFFFF' >>> _colorize((0, 32, 128)) '#002080' Nc3RK|]\}}|dt|z dz zz yw)rN)r)rrrts r/rz_colorize..s, ALDAqAA Q' 'Ls$'0#)sum enumeraterrupperr)r%rhs` r/rrs` "1A AIaL AAA CF ABA q3q6zQA 7Nr.)sync synchronouszsingle-threadedzdict[str, SchedulerGetCallable]named_schedulers)threaded)threads threading)multiprocessing) processesr4a The get= keyword has been removed. Please use the scheduler= keyword instead with the name of the desired scheduler like 'threads' or 'processes' x.compute(scheduler='single-threaded') x.compute(scheduler='threads') x.compute(scheduler='processes') or with a function that takes the graph and keys x.compute(scheduler=my_scheduler_function) or with a Dask client x.compute(scheduler=client) cjrtt|t|r|Sdt|jvrt |dr |j St|tr|j}d}tr8tJtt5tjdd}ddd|tvr |rt!j"dt|S|dvr-|st%d |d t&Jt'j Std d j)t+tzt|t,ret/|d d}|t1j dt2}t|t4r|dkDsJt7t8j:|j<|Stdt?|zt1j ddr tAt1j ddSt1j ddrtt ddl!m"}|j S#1swYxYw#tFtf$rYnwxYw| |jHS|r|Dcgc]}|| ncc}w}}|r0|djHtKfd|Ds tdSy)a{Get scheduler function There are various ways to specify the scheduler to use: 1. Passing in scheduler= parameters 2. Passing these into global configuration 3. Using a dask.distributed default Client 4. Using defaults of a dask collection This function centralizes the logic to determine the right scheduler to use from those many options Nr$rFT) allow_globalzkRunning on a single-machine scheduler when a distributed client is active might lead to unexpected results.)zdask.distributedr(z Requested z scheduler but no Client active.z!Expected one of [distributed, %s]z, _max_workers num_workersrzUnexpected scheduler: %sr})r}r%c3<K|]}|jk(ywrs)__dask_scheduler__)rcrs r/rz get_scheduler..sD 11''3. szCompute called on multiple collections with differing default schedulers. Please specify a scheduler=` parameter explicitly in compute or globally with `dask.config.set`.)&rO get_err_msgrNr\rxr]rrIrMlowerr0r)r r currentr0warningswarnr r+joinsortedrr^rrr r r get_asyncsubmitreprrr(r&r,r;all)rr}rr~client_availabler9r&r<s` r/rr/s  $$ I   i11 1gi6O==  3 '!)I$ %')555j)&..D.A'+$*,,#MMF( 22AA'&$YK/OP/:::.0444 7ii'7 89: 8 ,")^TBK"$jj B k84q HH5??I,<,>> a.__dask_keys__() # doctest: +SKIP ["foo", "bar"] >>> get_collection_names(a) # doctest: +SKIP {"foo", "bar"} >>> b.__dask_keys__() # doctest: +SKIP [[("foo-123", 0, 0), ("foo-123", 0, 1)], [("foo-123", 1, 0), ("foo-123", 1, 1)]] >>> get_collection_names(b) # doctest: +SKIP {"foo-123"} zExpected Dask collection; got )r4rOr\rrr<) collectionrs r/r;r;sS j )8j9I8JKLL*1*2J2J2L*M N*MQ a *M NN NsAct|tr|rt|dtr|dSt|tr|Std|)aGiven a dask collection's key, extract the collection name. Parameters ---------- key: string or tuple Dask collection's key, which must be either a single string or a tuple whose first element is a string (commonly referred to as a collection's 'name'), Examples -------- >>> get_name_from_key("foo") 'foo' >>> get_name_from_key(("foo-123", 1, 2)) 'foo-123' r/Expected str or a tuple starting with str; got )rIrLrMrO)rs r/r<r<sH #u#*SVS*A1v #s EcWM NNr. KeyOrStrTct|tr4|r2t|dtr|j|d|df|ddzSt|tr|j||St d|)aGiven a dask collection's key, replace the collection name with a new one. Parameters ---------- key: string or tuple Dask collection's key, which must be either a single string or a tuple whose first element is a string (commonly referred to as a collection's 'name'), rename: Mapping of zero or more names from : to. Extraneous names will be ignored. Names not found in this mapping won't be replaced. Examples -------- >>> replace_name_in_key("foo", {}) 'foo' >>> replace_name_in_key("foo", {"foo": "bar"}) 'bar' >>> replace_name_in_key(("foo-123", 1, 2), {"foo-123": "bar-456"}) ('bar-456', 1, 2) rrNrO)rIrLrMrrO)rrenames r/r=r=sr*#u#*SVS*A 3q63q6*,s12w66#szz#s## EcWM NNr.ct|tr+|r)t|dtrt|d|f|ddzSt|trt |}|dzt ||zSt d|)a'Clone a key from a Dask collection, producing a new key with the same prefix and indices and a token which is a deterministic function of the previous key and seed. Examples -------- >>> clone_key("x", 123) # doctest: +SKIP 'x-c4fb64ccca807af85082413d7ef01721' >>> clone_key("inc-cbb1eca3bafafbb3e8b2419c4eebb387", 123) # doctest: +SKIP 'inc-bc629c23014a4472e18b575fdaf29ee7' >>> clone_key(("sum-cbb1eca3bafafbb3e8b2419c4eebb387", 4, 3), 123) # doctest: +SKIP ('sum-c053f3774e09bd0f7de6044dbc40e71d', 4, 3) rrNrrO)rIrLrMr>r!r9rO)rseedprefixs r/r>r>sx#u#*SVS*A#a&$')CG33#s3|hsD111 EcWM NNr.)returnrQ)rVzdict[str, Any])rrrVzIterator[None])NN)Tr-)rz7Literal['cytoscape', 'ipycytoscape', 'graphviz'] | None)rwTFNNNN)NNNN)N ALL_COMPLETED)rVzset[str])rrrVrM)rrPrRzMapping[str, str]rVrP)rrPrTrrVrP)a __future__rrrrr@rrcollections.abcrrrconcurrent.futuresr contextlibr r contextvarsr functoolsr numbersr roperatorrtypingrrrtlzrrdaskrrdask._compatibilityr dask.corerrrr dask.systemr dask.typingrr dask.utilsrrr r!r"r)r+r'r0__all__ dask.tokenizer?r:r9rA__annotations__r3r2r4r1rrrrrrr7r5r8rr6rget_syncr0r1updater4dask_multiprocessingstripr=rrqr;r<rMrPr=r>r-r.r/ros0" #77'/"$((*'!1 " $GF2<43 / $m"m"`(*VKK\*:@$(,S l"3 n4@JJ  FJ d D dR   FJ HJ DHJV!`F( NN>>~~51 ||! =-11377 " EG# ([| O*O. Kc * O8Or.