LgxddlmZddlZddlZddlZddlmZmZmZm Z m Z m Z m Z m Z mZmZddlmZddlZddlZddlmZddlmZmZmZddlmZmZddlmZdd lm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&dd l'm(Z(d Z)Gd de!Z*Gdde*Z+Gdde!Z, ddZ-ddZ.ej^e,dZ0y) annotationsN) CollectionHashable ItemsViewIterableIteratorKeysViewMappingSequenceSet ValuesView)Any)config) clone_keyflattenis_dask_collection) keys_in_tasks reverse_dict)normalize_token)DaskCollectionGraphKey) ensure_dictimport_required key_split) get_templatechfd}jDchc] }|D]}| }}}Dcic] }|t}}jD]O\}}t||j z |jD]}||j ||Q|Scc}}wcc}w)z'Returns the dependencies between layerscrjD] \}}||vs |cStt|d)Nz not found)items RuntimeErrorrepr)keykvlayerss 3lib/python3.12/site-packages/dask/highlevelgraph.py_find_layer_containing_keyz>compute_layer_dependencies.._find_layer_containing_key#s;LLNDAqax#d3i[ 344)valuessetr rkeysadd)r&r(layerr#all_keysr$retr%s` r'compute_layer_dependenciesr1 s5 "(BESEHB# $V1ce8VC $ 1 AFFH!4ahhjAC FJJ1#6 7B J C $s B)B/ceZdZUdZded<ded< d ddZejddZejddZ dd Z dd Z d dd Z d Z dd ZdZy)LayeraxHigh level graph layer This abstract class establish a protocol for high level graph layers. The main motivation of a layer is to represent a collection of tasks symbolically in order to speedup a series of operations significantly. Ideally, a layer should stay in this symbolic state until execution but in practice some operations will force the layer to generate all its internal tasks. We say that the layer has been materialized. Most of the default implementations in this class will materialize the layer. It is up to derived classes to implement non-materializing implementations. Mapping[str, Any] | Nonercollection_annotationsNc|xs&tjjxsd|_|xs)tjt j dd|_y)aInitialize Layer object. Parameters ---------- annotations : Mapping[str, Any], optional By default, None. 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. See the dask.annotate function for more information. collection_annotations : Mapping[str, Any], optional. By default, None. Experimental, intended to assist with visualizing the performance characteristics of Dask computations. These annotations are *not* passed to the distributed scheduler. Nr5)daskget_annotationscopyrrgetr5)selfrr5s r'__init__zLayer.__init__DsP*'O$*>*>*@*E*E*GO4&<'  JJ/ 6A #r)cy)z/Return whether the layer is materialized or notTr;s r'is_materializedzLayer.is_materialized^sr)c"|jS)a?Return a set of all output keys Output keys are all keys in the layer that might be referenced by other layers. Classes overriding this implementation should not cause the layer to be materialized. Returns ------- keys: Set All output keys r,r?s r'get_output_keyszLayer.get_output_keyscsyy{r)c t|t|k(r1||jDcic]}||j||c}fSi}t}i}|j }|rf|j }||||<|j||||<||D].}||vs||vs |j ||j |0|rft||j|fScc}w)amRemove unnecessary tasks from the layer In other words, return a new Layer with only the tasks required to calculate `keys` and a map of external key dependencies. Examples -------- >>> inc = lambda x: x + 1 >>> add = lambda x, y: x + y >>> d = MaterializedLayer({'x': 1, 'y': (inc, 'x'), 'out': (add, 'x', 10)}) >>> _, deps = d.cull({'out'}, d.keys()) >>> deps {'out': {'x'}, 'x': set()} Returns ------- layer: Layer Culled layer deps: Map Map of external key dependencies r) lenr,get_dependenciesr+r9popr-MaterializedLayerr) r;r, all_hlg_keysr$ret_depsseenoutworkds r'cullz Layer.cullts2 t9D !DHIIKPKqD))!\::KP  uyy{ A!WCF//<@HQKa[D=Dy  ! !$2B2BCXMM#QsC(c"t|||gS)a(Get dependencies of `key` in the layer Parameters ---------- key: The key to find dependencies of all_hlg_keys: All keys in the high level graph. Returns ------- deps: set A set of dependencies )r)r;r#rIs r'rFzLayer.get_dependenciess\DI;77r)c ddlm} fd i}d}|jD]9\}}|vr+t|}d  |}| r|j||f}d}|||<;t ||fS)aCClone selected keys in the layer, as well as references to keys in other layers Parameters ---------- keys Keys to be replaced. This never includes keys not listed by :meth:`get_output_keys`. It must also include any keys that are outside of this layer that may be referenced by it. seed Common hashable used to alter the keys; see :func:`dask.base.clone_key` bind_to Optional key to bind the leaf nodes to. A leaf node here is one that does not reference any replaced keys; in other words it's a node where the replacement graph traversal stops; it may still have dependencies on non-replaced nodes. A bound node will not be computed until after ``bind_to`` has been computed. Returns ------- - New layer - True if the ``bind_to`` key was injected anywhere; False otherwise Notes ----- This method should be overridden by subclasses to avoid materializing the layer. r)chunksct|}|tur.|r,t|dr|dftfd|ddDzS|tur|Dcgc] }| c}S|tur*|j Dcic]\}}||c}}S |vr|S dt|Scc}wcc}}w#t $r|cYSwxYw)zhVariant of distributed.utils_comm.subs_multiple, which allows injecting bind_to rc3.K|] }|ywNr>).0i clone_values r' z3Layer.clone..clone_value..s&Eu!{1~usNF)typetuplecallablelistdictr TypeErrorr) otyprWr$r%rXis_leafr,seeds r'rXz Layer.clone..clone_values q'Ce|hqtn!w&Equ&E!EEE0121 A2267ggi@ida;q>)i@@} %  D))3@ !HsB)<B.B44 CCFT)dask.graph_manipulationrRr rbindrH) r;r,rdbind_torRdsk_newboundr#valuerXrcs `` @@r'clonez Layer.clonesB 3 *,**,JCd{T*#E*&7#[[%9E E GCL'!)500r)ct|j|j}|jj |j|S)z#Default shallow copy implementation)r[__new__ __class____dict__update)r;objs r'__copy__zLayer.__copy__s54j  0 DMM* r)c |dk7r t|}n8t|drt|j}n|jj}d}|j rI|j j ddk(r+|j j d}|rddlm}||}tdj|j||||j|| S) Nnamer[dask.array.core.ArrayrRr)svgzhighlevelgraph_layer.html.j2) materialized shortname layer_indexhighlevelgraph_keyinfo dependenciessvg_repr) rhasattrrurn__name__r5r:dask.array.svgrwrrenderr@layer_info_dict)r;rzr{r}ryr~rRrws r' _repr_html_zLayer._repr_html_s  #!"45I T6 "!$)),I//I  ' '++//7;RR0044X>F.v;:;BB--/#1%%'%C  r)ct|j|jt|j d}|j C|j j D]&\}}tjt|||<(|jI|jj D],\}}|dk7s tjt|||<.|S)N) layer_typer@znumber of outputsrR) r[rr@rErCrr htmlescapestrr5)r;r|r#vals r'rzLayer.layer_info_dict#st*--#335$'(<(<(>$?#@     ' ,,224S KKC1S 5  & & 2 77==?S(? $ CH 5DI@ r)NN)rr4r5r4)returnbool)rzSet[Key])r,set[Key]rICollection[Key]rz$tuple[Layer, Mapping[Key, set[Key]]])r#rrIrrr+rU)r,r+rdrrgz Key | Nonerztuple[Layer, bool])rtrtr>)r __module__ __qualname____doc____annotations__r<abcabstractmethodr@rCrOrFrkrrrrr>r)r'r3r31s *)4415;? - !9 4   .N.N,;.N -.N`8*# I1I1I1 I1  I1V  :r)r3cJeZdZdZd d fd ZdZdZdZdZdZ dZ xZ S) rHzFully materialized layer of `Layer` Parameters ---------- mapping: Mapping The mapping between keys and tasks, typically a dask graph. c6t|||||_y)N)rr5)superr<mapping)r;rrr5rns r'r<zMaterializedLayer.__init__=s$ #r?s r'r@z!MaterializedLayer.is_materializedOsr)c"|jSrUrBr?s r'rCz!MaterializedLayer.get_output_keysRsyy{r)r)rr ) rrrrr<rrrrr@rC __classcell__)rns@r'rHrH4s+ !"!r)rHc:eZdZUdZded<ded<ded<ded <d ed < d# d$d ZedZe d% d&dZd'dZ d(dZ d)dZ d*dZ d+dZ d,dZd-dZd.dZd/dZed0dZd1dZed2dZd3dZd4dZd5dZd6dZd7d Zd8d!Zd8d"Zy )9HighLevelGrapha Task graph composed of layers of dependent subgraphs This object encodes a Dask task graph that is composed of layers of dependent subgraphs, such as commonly occurs when building task graphs using high level collections like Dask array, bag, or dataframe. Typically each high level array, bag, or dataframe operation takes the task graphs of the input collections, merges them, and then adds one or more new layers of tasks for the new operation. These layers typically have at least as many tasks as there are partitions or chunks in the collection. The HighLevelGraph object stores the subgraphs for each operation separately in sub-graphs, and also stores the dependency structure between them. Parameters ---------- layers : Mapping[str, Mapping] The subgraph layers, keyed by a unique name dependencies : Mapping[str, set[str]] The set of layers on which each layer depends key_dependencies : dict[Key, set], optional Mapping (some) keys in the high level graph to their dependencies. If a key is missing, its dependencies will be calculated on-the-fly. Examples -------- Here is an idealized example that shows the internal state of a HighLevelGraph >>> import dask.dataframe as dd >>> df = dd.read_csv('myfile.*.csv') # doctest: +SKIP >>> df = df + 100 # doctest: +SKIP >>> df = df[df.name == 'Alice'] # doctest: +SKIP >>> graph = df.__dask_graph__() # doctest: +SKIP >>> graph.layers # doctest: +SKIP { 'read-csv': {('read-csv', 0): (pandas.read_csv, 'myfile.0.csv'), ('read-csv', 1): (pandas.read_csv, 'myfile.1.csv'), ('read-csv', 2): (pandas.read_csv, 'myfile.2.csv'), ('read-csv', 3): (pandas.read_csv, 'myfile.3.csv')}, 'add': {('add', 0): (operator.add, ('read-csv', 0), 100), ('add', 1): (operator.add, ('read-csv', 1), 100), ('add', 2): (operator.add, ('read-csv', 2), 100), ('add', 3): (operator.add, ('read-csv', 3), 100)} 'filter': {('filter', 0): (lambda part: part[part.name == 'Alice'], ('add', 0)), ('filter', 1): (lambda part: part[part.name == 'Alice'], ('add', 1)), ('filter', 2): (lambda part: part[part.name == 'Alice'], ('add', 2)), ('filter', 3): (lambda part: part[part.name == 'Alice'], ('add', 3))} } >>> graph.dependencies # doctest: +SKIP { 'read-csv': set(), 'add': {'read-csv'}, 'filter': {'add'} } See Also -------- HighLevelGraph.from_collections : typically used by developers to make new HighLevelGraphs zMapping[str, Layer]r&Mapping[str, set[str]]r}dict[Key, set[Key]]key_dependenciesr__to_dictr+_all_external_keysNc ||_|xsi|_|jDcic]#\}}|t|tr|n t |%c}}|_ycc}}wrU)r}rr isinstancer3rHr&)r;r&r}rr$r%s r'r<zHighLevelGraph.__init__s_ ) 0 6B  &1 Jq%(q.?.B B&   s(Acrt|stt||j}t |t rPt |jd}|||<t |jd}t|j||<n t|}||||i}||h|ti}|||S)z4`from_collections` optimized for a single collectionTr9) rr`r[__dask_graph__rrrr&r}r+__dask_layers___get_some_layer_name)clsrur. collectiongraphr&depsr#s r'_from_collectionzHighLevelGraph._from_collections"*-D,- -))+ e^ , D9F F4Lu11=DZ779:DJ&z2CE3.F3%ce,D64  r)c@t|dk(r|j|||dS||i}t}||i}tj|t D]}t |r|j}t|trS|j|j|j|j|t|jz}t|} ||| <|j| t|| <t!t#||||S)acConstruct a HighLevelGraph from a new layer and a set of collections This constructs a HighLevelGraph in the common case where we have a single new layer and a set of old collections on which we want to depend. This pulls out the ``__dask_layers__()`` method of the collections if they exist, and adds them to the dependencies for this new layer. It also merges all of the layers from all of the dependent collections together into the new layers for this graph. Parameters ---------- name : str The name of the new layer layer : Mapping The graph layer itself dependencies : List of Dask collections A list of other dask collections (like arrays or dataframes) that have graphs themselves Examples -------- In typical usage we make a new task layer, and then pass that layer along with all dependent collections to this method. >>> def add(self, other): ... name = 'add-' + tokenize(self, other) ... layer = {(name, i): (add, input_key, other) ... for i, input_key in enumerate(self.__dask_keys__())} ... graph = HighLevelGraph.from_collections(name, layer, dependencies=[self]) ... return new_collection(name, graph) rZr)r#)rErr+toolzuniqueidrrrrrpr&r}rrr-r`r[) rrur.r}r&name_deprrrr#s r'from_collectionszHighLevelGraph.from_collectionssP |  !''e\!_E E U%)8$4,,|$>$@ AAH.z:C"'F3KLL% #DIZ 011=64  r)c& |j||S#t$rYnwxYw |j|d|S#tttf$rYnwxYw|jj D]} ||cS#t$rYwxYwt|)Nr)r&KeyError IndexErrorr`r*)r;r#rNs r'rzHighLevelGraph.__getitem__s ;;s#C( (    ;;s1v&s+ +*i0   ##%A v   & sms-  9AA1A88 BBcVtd|jjDS)Nc32K|]}t|ywrU)rE)rVr.s r'rYz)HighLevelGraph.__len__..s@+?%3u:+?s)sumr&r*r?s r'rzHighLevelGraph.__len__s" @4;;+=+=+?@@@r)c4t|jSrU)rto_dictr?s r'rzHighLevelGraph.__iter__sDLLN##r)cb |jS#t$rt|x}|_|cYSwxYw)zIEfficiently convert to plain dict. This method is faster than dict(self).)rAttributeErrorr)r;rLs r'rzHighLevelGraph.to_dicts6 ==  "-d"3 3C$-J s ..c>|jjS)zGet all keys of all the layers. This will in many cases materialize layers, which makes it a relatively expensive operation. See :meth:`get_all_external_keys` for a faster alternative. )rr,r?s r'r,zHighLevelGraph.keys&s ||~""$$r)c |jS#t$rTt}|jj D]!}|j |j #||_|cYSwxYw)zGet all output keys of all layers This will in most cases _not_ materialize any layers, which makes it a relative cheap operation. Returns ------- keys: set A set of all external keys )rrr+r&r*rprC)r;r,r.s r'get_all_external_keysz$HighLevelGraph.get_all_external_keys.sf ** * D++- E1134 . '+D #K s AA+*A+c>|jjSrU)rr r?s r'r zHighLevelGraph.itemsEs||~##%%r)c>|jjSrU)rr*r?s r'r*zHighLevelGraph.valuesHs||~$$&&r)c$|j}||jjz }|rV|jjD]9}||jzD]!}|j |||j|<#;|jS)zGet dependencies of all keys This will in most cases materialize all layers, which makes it an expensive operation. Returns ------- map: Mapping A map that maps each key to its dependencies )r,rr&r*rF)r;r/ missing_keysr.r$s r'get_all_dependenciesz#HighLevelGraph.get_all_dependenciesKs99;$"7"7"<"<">> ++-% 4A/4/E/Ea/RD))!,5.$$$r)c,t|jSrU)rr}r?s r' dependentszHighLevelGraph.dependents^sD--..r)ctt|jdt|jd|jj S)NTr)rrr&r}rr9r?s r'r9zHighLevelGraph.copybs?  $ / )) 5  ! ! & & (  r)cZi}i}|D]}t|tr7|j|j|j|jJt|t r7||t t|<t|t t|<t||||SrU) rrrpr&r}r rrr+r`)rgraphsr&r}gs r'mergezHighLevelGraph.mergeis#%,. A!^, ahh'##ANN3Aw'%&s2a5z"+.5 SAZ(l"6<((r)c >ddlm}t|fi|}|||||S)a? Visualize this dask high level graph. Requires ``graphviz`` to be installed. Parameters ---------- 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 the graph is rendered in the Jupyter notebook only. format : {'png', 'pdf', 'dot', 'svg', 'jpeg', 'jpg'}, optional Format in which to write output file. Default is 'svg'. color : {None, 'layer_type'}, optional (default: None) Options to color nodes. - None, no colors. - layer_type, color nodes based on the layer type. **kwargs Additional keyword arguments to forward to ``to_graphviz``. Examples -------- >>> x.dask.visualize(filename='dask.svg') # doctest: +SKIP >>> x.dask.visualize(filename='dask.svg', color='layer_type') # 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 dask.base.visualize # low level variant r)graphviz_to_file)dask.dotr to_graphviz)r;filenameformatkwargsrrs r' visualizezHighLevelGraph.visualizexs(L .  ' 'Hf-r)cD|jjDcic]\}}|t|}}}|jDcic]}|g}}g}|jjD]4\}}|D]}||j||r$|j|6g}t|dkDra|j }|j|||D])} || xxdzcc<|| dk(s|j| +t|dkDra|Scc}}wcc}w)aSort the layers in a high level graph topologically Parameters ---------- hlg : HighLevelGraph The high level graph's layers to sort Returns ------- sorted: list List of layer names sorted topologically rrZ)r}r rEappendrG) r;r$r%degree reverse_depsreadydepr0r.rdeps r'_toposort_layerszHighLevelGraph._toposort_layerss)-(9(9(?(?(AB(A1!SV)(AB=A=N=N-O=Nae=N -O%%++-DAqS!((+ Q . %j1nIIKE JJu $U+t ! $<1$LL&,%j1n !C-Os D Dcddlm}tt|}|j }i}i}t |j D]}|j|}|j|j} | s4|j| |\} } t} | jD]} | | z} | | jz} || z}| ||<t||s9t|ts)|jst|t| k(s|j!| t|j#}|Dcic]}||j$||z}}t'|||Scc}w)aReturn new HighLevelGraph with only the tasks required to calculate keys. In other words, remove unnecessary tasks from dask. Parameters ---------- keys iterable of keys or nested list of keys such as the output of ``__dask_keys__()`` Returns ------- hlg: HighLevelGraph Culled high level graph r) Blockwise) dask.layersrr+rrreversedrr& intersectionrCrOr*rrHr@rErpr,r}r)r;r,rkeys_set all_ext_keys ret_layers ret_key_deps layer_namer. output_keys culled_layer culled_deps external_depsrNret_layers_keysret_dependenciess r'rOzHighLevelGraph.cullsy *wt}%113   "4#8#8#:;JKK +E #//0E0E0GHK,1JJ{L,Q) k!$ $++-A!Q&M.!=!=!?? M)*6 :&ui0!%):;--/SZ3{CS5S!'' 4E.C.C.EE EH  j*:;;r)c |jjD]W\}}||jvrtdt |d|D]'}||jvstt |dY|jj D]}t |drJt|j}|jj}|j}||k7r#tdt|dt||D]W}|j|||k7stdt |dt |j|dt ||d y) Nz dependencies[z] not found in layersz not found in dependenciesrzincorrect dependencies keys z expected zincorrect HLG dependencies[z]: z from task dependencies) r}r r& ValueErrorr"r*rr1r,r+) r;rrrr.r}dep_key1dep_key2r$s r'validatezHighLevelGraph.validate s $ 1 1 7 7 9 J, #D$4#55JKd///$S {2L%MNN !:[['')E5-0 00*2$++> $$))+$$& x .s8}.?@M,.  A  #|A6 1$q'#d4CTCTUVCW>X=YZ $\!_ 566MOr)c Nt|jdt|jd}|d|jj d|jjdt t|dz }t|jD]\}}|d|d|d z }|S) Nz with z layers. <.z object at z>  z.  ) r[rrEr&rnrhexr enumerater)r;representationrWlayerkeys r'__repr__zHighLevelGraph.__repr__Bs J//0s4;;7G6H SAdnn778$..:Q:Q9RR]^abdeibj^k]llopp$T%:%:%<=KAx !Bxj3 3N>r)c tdjt|j|j|j |j t|jS)Nzhighlevelgraph.html.j2)r[r&toposortlayer_dependencies n_outputs) rrr[rr&rr}rErr?s r'rzHighLevelGraph._repr_html_IsZ45<<d$$;;**,#00$4467 =  r)rU)r&zMapping[str, Graph]r}rrzdict[Key, set[Key]] | None)r>)rurr.rr}zSequence[DaskCollection]rr)r#rrr)rint)rz Iterator[Key])rzdict[Key, Any])rr )rr)rzItemsView[Key, Any])rzValuesView[Any])rr)rzdict[str, set[str]])rr)rrrr)z dask-hlg.svgN)rz list[str])r,z Iterable[Key]rr)r&z Iterable[str]rr)rNonerr)rrrrrr< classmethodrrrrrrr,rr r*rpropertyrr9rrrrOrrr rr>r)r'rrVs$?B (())N 8<  #  -  5  !!$ 24 ;!;!;!/ ;!  ;!;!z,A$%.&'%&//  ) )*X>CJJ<0 D r)rc ddlm}m} tdd} |xsi}|xsi}|xsi}|xsi}|xsi}||d<d|d<d|d <|j || j ||| } i} |j D]} t|j| | | <t| j}t| j}i}|jd }|d k(rd dgddgddgddgddgddgddgddgd}|j D]`} | | }|j| i}|| |}||k(rdntd| | |z ||z z dzz}tt|j| j }d|j#ddd| | d}|j| j$}|r|jddk(rN|d|jdd|jd d!|jd"d#|jd$d% z }|jdd&k(rd'd(i}|jd)}|d*|jd+d,|j|jd-d%t|d.tt|d/kr t|nd0d% z }|j'd1t||j'd2t||j'd3t||d k(rUj|d}d4|j|d5<|j'd6t||j'd7d8| j(|fi|c|j j+D].\} }| | }|D]}| |}| j-||0|d k(rd9} d:}!j+D]\}}|d5s |!d;|dd<|d=z }!|!d>z }!|j| i}|j'd1t|!|j'd2d?|j'd@dA| j(| fi|| S)BNr)labelrugraphvizaJDrawing dask graphs with the graphviz visualization engine requires the `graphviz` python library and the `graphviz` system library. Please either conda or pip install as follows: conda install python-graphviz # either conda install python -m pip install graphviz # or pip install and follow installation instructionsrankdirboxshape helveticafontname) graph_attr node_attr edge_attrcolorrz#CCC7F9Fz#F9CCC7z#FFD9F2z#D9F2FFz#D9FFE6z#DBDEE5)DataFrameIOLayer ShuffleLayerSimpleShuffleLayerArrayOverlayLayerBroadcastJoinLayerrBlockwiseLayerrH)cachezA r3rtz Layer with z Tasks. r[rvz Array Shape: z Data Type: dtypez Chunk Size: chunksizez Chunk Type: chunk_typerzdask.dataframe.core.DataFramezpandas.core.frame.DataFramepandascolumnszNumber of Partitions: npartitionsz DataFrame Type: dataframe_typez DataFrame Columns: (z[...]rfontsizetooltipTrZ fillcolorstylefilledrzn<zz
Legend: Layer types
z
>20margin0)rrrurrpDigraphr}rEr&minr*maxr:rrr[rreplacer5 setdefaultnoder edge)"hgdata_attributesfunction_attributesrrrrrrrurrn_tasksr. min_tasks max_tasksr'r  layer_colorsrattrs node_label node_sizer node_tooltipslayer_cadftypecols node_colorrrdep_name legend_title legend_labels" r'rrSs% dH&+O-3!rJRIRI#JyIg'Ijfi  AGRYYu-.!GNN$%IGNN$%I E JJw E !*E 2&.#,e"4"+U!3#,e"4#U+(%0"+U!3  %[ ##E2.5. I% RGENY69y;PQUWWWX  bii./889 ##GR01gen=MY W 99U#:: ||F#'>>#HLL$9#:;""*,,w"7!89##+<< #<"=>##+<< #=">bB ||F#'FF7B||I.,X\\--H,IJ''-zz(,,?O2P'Q&RRT4yk!53s4y>UWCWc$i]d5eegi #j/2 S^4 C $67 L %))*5a8J.2L  Z ( +   [#j/ :   Wh /z#U#_!b,,. t%[ CCyH FF8Z (/    ;  ".!3!3!5 JQx"3E!H:R |: VV "6  # ##L"5 #l"34 T* 3'|%u% Hr)c~ |j\}|S#ttf$rtt |cYSwxYw)zLSomehow get a unique name for a Layer from a non-HighLevelGraph dask mapping)rrrrr)rrus r'rrsA#,,. J '#2j>""#s #<<cZtt|jjSrU)rr^r&r,)hlgs r'register_highlevelgraphrUs 4  12 33r))NNBTNNNr)1 __future__rrr9rcollections.abcrrrrr r r r r rtypingrtlzrr7r dask.baserrr dask.corerr dask.tokenizer dask.typingrrr dask.utilsrrr dask.widgetsrr1r3rHrrrregisterrUr>r)r'rbs"     <<1)22>>%"@E@FDz Uz ~ F R#.)4*4r)