
    biȍ                    &   U d dl mZ 	 d dlZd dlZd dlZd dlmZ d dlmZm	Z	m
Z
mZmZ d dlmZmZ d dlmZmZmZ d dlmZ d dlmZ d d	lmZmZ  ed
      ZdddZej:                  dk\  rdddZneZej>                  e_        d Z d Z! ejD                         Z#d:dZ$d Z%d Z& G d de	      Z'dZ(d Z)	 	 	 	 	 	 	 	 d;dZ*	 d<	 	 	 d=dZ+d>dZ, G d d      Z- G d d      Z. e/       Z0de1d <    G d! d"e.      Z2 G d# d$e.      Z3d?d%Z4 G d& d'e.      Z5 G d( d)e5e
      Z6 G d* d+e6      Z7 G d, d-e6      Z8 G d. d/e6      Z9 G d0 d1e6e      Z: G d2 d3e      Z; G d4 d5e      Z<	 	 d@	 	 	 	 	 	 	 dAd6Z=d7 Z>	 	 	 	 	 	 dBd8Z?ej                  dCd9       ZAy)D    )annotationsN)defaultdict)Callable	ContainerIterableMappingMutableMapping)	lru_cachepartial)AnyTypeVarcast)sizeof)Key)funcnameis_namedtuple_instance_TFstrictc             #    K   |dk  rt        d      t        |       }t        t        j                  ||            x}rB|rt        |      |k7  rt        d      | t        t        j                  ||            x}rAyyw)a  Batch data into tuples of length *n*. If the number of items in
    *iterable* is not divisible by *n*:
    * The last batch will be shorter if *strict* is ``False``.
    * :exc:`ValueError` will be raised if *strict* is ``True``.

    >>> list(batched('ABCDEFG', 3))
    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G',)]

    On Python 3.13 and above, this is an alias for :func:`itertools.batched`.
       zn must be at least onezbatched(): incomplete batchN)
ValueErroritertuple	itertoolsislicelen)iterablenr   itbatchs        J/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/dask/_task_spec.py_batchedr#   J   s~      	1u122	hB))"a01
1%
1c%jAo:;; ))"a01
1%
1s   A=B Bi c               2    t        j                  | ||      S )Nr   )r   batched)r   r   r   s      r"   r%   r%   `   s      1V<<    c                     | S N argss    r"   identityr,   j   s    Kr&   c                     | |      S r(   r)   )typr+   s     r"   _identity_castr/   n   s    t9r&   c                   t        | t              r| S t        | t              rt        | j                        S t        | t
              rW| j                         D ci c]  \  }}|t        |       }}}t        d |j                         D              rt        |      S t        | t        t        t        f      rt        d | D              }t        d |D              rdt        | t              rt        | S t        | t              rt        | S t        | t              r$t!        |       rt#        d| t              S t%        | S | S c c}}w )a  Tokenize user input into GraphNode objects

    Note: This is similar to `convert_legacy_task` but does not
    - compare any values to a global set of known keys to infer references/futures
    - parse tuples and interprets them as runnable tasks
    - Deal with SubgraphCallables

    Parameters
    ----------
    obj : _type_
        _description_

    Returns
    -------
    _type_
        _description_
    c              3  <   K   | ]  }t        |t                y wr(   
isinstance	GraphNode).0vs     r"   	<genexpr>zparse_input.<locals>.<genexpr>   s     FAz!Y'F   c              3  2   K   | ]  }t        |        y wr(   )parse_inputr5   os     r"   r7   zparse_input.<locals>.<genexpr>   s     !>Q+a.!>   c              3  <   K   | ]  }t        |t                y wr(   r2   r;   s     r"   r7   zparse_input.<locals>.<genexpr>   s     CAz!Y'Cr8   N)r3   r4   TaskRefAliaskeydictitemsr:   anyvaluesDictlistsetr   ListSetr   _wrap_namedtuple_taskTuple)objkr6   parsed_dictparsed_collections        r"   r:   r:   u   s   $ #y!
#wSWW~#t58YY[ATQq+a.(AAF1C1C1EFF$$#c5)*!!>#!>>C1BCC#t$.//#s#-..#u%)#.0sKHH/00J! Bs   Ec           	        t        |d      r=|j                         \  }}|j                         D  ci c]  \  } }|  ||       }} }nt        |d      r|j                         }i }t	         t              t        ||                  }t         t        t        t        |            |t                    S c c}} w )N__getnewargs_ex____getnewargs__)hasattrrR   rC   rS   r:   typemapTaskr   _instantiate_named_tuplerF   )rN   rM   parsernew_argskwargsr6   args_converteds          r"   rK   rK      s    s'(002&+1<<>:41a!VAY,::	&	'%%' hFH0E!FGN	7+T#Y7f  ;s   B:c                     | |i |S r(   r)   )r.   r+   r[   s      r"   rX   rX      s    r&   c                  *    e Zd ZU ded<   dZd ZddZy)_MultiContainerr   	containerr`   c                    || _         y r(   ra   )selfr`   s     r"   __init__z_MultiContainer.__init__   s	    "r&   c                @    t        fd| j                  D              S )Nc              3  &   K   | ]  }|v  
 y wr(   r)   )r5   cr<   s     r"   r7   z/_MultiContainer.__contains__.<locals>.<genexpr>   s     2a162s   )rD   r`   )rc   r<   s    `r"   __contains__z_MultiContainer.__contains__   s    24>>222r&   N)r<   objectreturnbool)__name__
__module____qualname____annotations__	__slots__rd   rh   r)   r&   r"   r_   r_      s    I#3r&   r_   c                    i }|j                  |        t        ||      D ]  \  }}t        d |      ||<    t        ||g      }||   S )N)keys)updatezipDataNodeexecute_graph)	inner_dskoutkeyinkeysdependenciesfinalrN   r6   ress           r"   _execute_subgraphr}      sU    E	LLFL) %1D!$a%
VH
-Cv;r&   c           	        t        |t              r|S t        |      t        u rj|rht	        |d         rZ|d   |dd  }}g }|D ]<  }t        |t
              rt        |      }nt        d |      }|j                  |       > t        | |g| S 	 t        |t        t        t        t        f      r|v r| t        |      S t        | |      S t        |t        t        t         t"        f      rt%        |      rt'        | |t)        t        d             S t        fd|D              }t+        d |D              rt        | t,        g|dt        |      iS t/        t0         t        |      |            S t        |t2              r.| t        |j4                        S t        | |j4                        S |S # t        $ r Y w xY w)Nr   r   target)all_keysc              3  8   K   | ]  }t        d |        y wr(   )convert_legacy_task)r5   tr   s     r"   r7   z&convert_legacy_task.<locals>.<genexpr>   s     U1 3D!X FUs   c              3  <   K   | ]  }t        |t                y wr(   r2   )r5   as     r"   r7   z&convert_legacy_task.<locals>.<genexpr>   s     A:a+Ar8   r.   )r3   r4   rU   r   callablerB   rF   r   appendrW   intfloatstrr@   	TypeErrorrG   rH   	frozensetr   rK   r   rD   r/   r   r   r?   rA   )	rA   taskr   funcr+   rZ   r   newparsed_argss	     `      r"   r   r      s   
 $	"DzUta(9!Wd12hd 	!A!T"1g)$8<OOC 	! C)))	dS%e45x; ;& T22
 $uc956!$'('%   UPTUUKA[AACN+N4:NNB
T
; 788	D'	";?"TXX..7  s   0F8 F8 8	GGc                    |t        |       }i }| j                         D ]S  \  }}t        |||      }t        |t              r|j
                  |k(  r3t        |t              st        ||      }|||<   U |S r(   )rH   rC   r   r3   r@   r   r4   ru   )dskr   new_dskrN   argr   s         r"   convert_legacy_graphr     s{     s8G))+ 331aAHHMAy)AA
 Nr&   c                Z   |st        d      t        |       } t        |      }t               }|r|j	                         }||v s|| vr|j                  |       | |   }t        |t              r|j                  }||vr|| v rt        ||         dk(  ry| j	                  |      j                         }|| |<   ||_        t        |t              r#|j                  |       |j                  |       n|j                  |j                         |j                  |j                         |r| S )zRemove trivial sequential alias chains

    Example:

        dsk = {'x': 1, 'y': Alias('x'), 'z': Alias('y')}

        resolve_aliases(dsk, {'z'}, {'x': {'y'}, 'y': {'z'}}) == {'z': 1}

    zNo keys providedr   )r   rB   rG   rH   popaddr3   r@   r   r   copyrA   r   discardextendrz   )	r   rr   
dependentsworkseenrN   r   
target_keytnews	            r"   resolve_aliasesr     s    +,,
s)C:D5D
HHJ9FaJ $&#% 
:./14wwz*//1AdE*KKNLLOKK 1 12ANN#M N Jr&   c                  P    e Zd ZU ded<   dZddZd Zd ZddZddZ	d	 Z
dddZy
)r?   KeyTypevalrA   c                    || _         y r(   r   rc   rA   s     r"   rd   zTaskRef.__init__Q  s	    r&   c                ,    t        | j                        S r(   )r   rA   rc   s    r"   __str__zTaskRef.__str__T      488}r&   c                L    t        |       j                   d| j                  dS N())rU   rl   rA   r   s    r"   __repr__zTaskRef.__repr__W  s$    t*%%&a|155r&   c                ,    t        | j                        S r(   )hashrA   r   s    r"   __hash__zTaskRef.__hash__Z      DHH~r&   c                V    t        |t              sy| j                  |j                  k(  S NF)r3   r?   rA   rc   values     r"   __eq__zTaskRef.__eq__]  s"    %)xx599$$r&   c                (    t         | j                  ffS r(   )r?   rA   r   s    r"   
__reduce__zTaskRef.__reduce__b  s    ##r&   Nc                    | j                   |v rY|| j                      }t        |t              r|j                  i | j                         S t        |t              r|S t	        |      S | S )Nr   )rA   r3   r4   
substituter?   )rc   subsrA   r   s       r"   r   zTaskRef.substitutee  sZ    88ttxx.C#y)~~bdhh~77C)
s|#r&   )rA   r   rj   r   r   ri   rj   rk   r(   )r   rB   rA   KeyType | Nonerj   zTaskRef | GraphNode)rl   rm   rn   ro   rp   rd   r   r   r   r   r   r   r)   r&   r"   r?   r?   M  s/    	LI6%
$	r&   r?   c                      e Zd ZU ded<   ded<    ee      Zd Zd Zedd       Z	edd       Z
edd	       Zdd
ZddZddZedd       ZddZ	 d	 	 	 	 	 ddZedddd       Zeed               Zy)r4   r   rA   r   _dependenciesc                ,    t        | j                        S r(   )r@   rA   r   s    r"   refzGraphNode.refw  s    TXXr&   c                    t         r(   NotImplementedErrorr   s    r"   r   zGraphNode.copyz      !!r&   c                     yr   r)   r   s    r"   data_producerzGraphNode.data_producer}      r&   c                    | j                   S r(   )r   r   s    r"   rz   zGraphNode.dependencies  s    !!!r&   c                     yr   r)   r   s    r"   block_fusionzGraphNode.block_fusion  r   r&   c                    | j                   sy t        | j                         t        |      z
  x}rt        d|       y )Nz,Not enough arguments provided: missing keys )rz   rH   RuntimeError)rc   rE   missings      r"   _verify_valueszGraphNode._verify_values  sE      $++,s6{::7:!MgYWXX ;r&   c                    t        d      )NzNot implementedr   rc   rE   s     r"   __call__zGraphNode.__call__  s    !"344r&   c                ^    t        |      t        |       uryddlm}  ||        ||      k(  S )NFr   tokenize)rU   dask.tokenizer   )rc   r   r   s      r"   r   zGraphNode.__eq__  s+    ;d4j(*~%00r&   c                     yr   r)   r   s    r"   is_corozGraphNode.is_coro  r   r&   c                      j                         }t         fd|D              t        j                  t	                     z   S )Nc              3  H   K   | ]  }t        t        |              y wr(   )r   getattrr5   slrc   s     r"   r7   z'GraphNode.__sizeof__.<locals>.<genexpr>  s     A6'$+,As   ")get_all_slotssumsys	getsizeofrU   )rc   	all_slotss   ` r"   
__sizeof__zGraphNode.__sizeof__  s<    &&(	AyAACMMJE
 
 	
r&   Nc                    t         )aa  Substitute a dependency with a new value. The new value either has to
        be a new valid key or a GraphNode to replace the dependency entirely.

        The GraphNode will not be mutated but instead a shallow copy will be
        returned. The substitution will be performed eagerly.

        Parameters
        ----------
        subs : dict[KeyType, KeyType  |  GraphNode]
            The mapping describing the substitutions to be made.
        key : KeyType | None, optional
            The key of the new GraphNode object. If None provided, the key of
            the old one will be reused.
        r   rc   r   rA   s      r"   r   zGraphNode.substitute  s
    " "!r&   r   c           	     b   t        d |D              rt        d      t        |      dk(  r|d   j                  i |       S t	               }t	               }|D ]8  }|j                  |j                         |j                  |j                         : t        t        ||z
  t                    }||z
  }t        |      dkD  rt        d|       |j                         }t        | xs |t        |D ci c]  }|j                  | c}||gd |D        dt        d	 |D              iS c c}w )
a  Fuse a set of tasks into a single task.

        The tasks are fused into a single task that will execute the tasks in a
        subgraph. The internal tasks are no longer accessible from the outside.

        All provided tasks must form a valid subgraph that will reduce to a
        single key. If multiple outputs are possible with the provided tasks, an
        exception will be raised.

        The tasks will not be rewritten but instead a new Task will be created
        that will merely reference the old task objects. This way, Task objects
        may be reused in multiple fused tasks.

        Parameters
        ----------
        key : KeyType | None, optional
            The key of the new Task object. If None provided, the key of the
            final task will be used.

        See also
        --------
        GraphNode.substitute : Easier substitution of dependencies
        c              3  8   K   | ]  }|j                   d u   y wr(   r   r5   r   s     r"   r7   z!GraphNode.fuse.<locals>.<genexpr>  s     ,quu},s   z#Cannot fuse tasks with missing keysr   r   r   z(Cannot fuse tasks with multiple outputs c              3  2   K   | ]  }t        |        y wr(   )r?   )r5   rN   s     r"   r7   z!GraphNode.fuse.<locals>.<genexpr>  s     0Qgaj0r=   _data_producerc              3  4   K   | ]  }|j                     y wr(   )r   r   s     r"   r7   z!GraphNode.fuse.<locals>.<genexpr>  s     >1q>s   )rD   r   r   r   rH   rs   rz   r   rA   r   sortedr   r   rW   r}   )rA   tasksr   all_depsr   external_depsleafsrx   s           r"   fusezGraphNode.fuse  s'   2 ,e,,BCCu:?8&&rs&335!$ 	 AOOANN+LL	  fX%8dCD8#u:>GwOPPM6$%!QUUAX%
 1-0
 >>>
 	
 &s   4D,c                    t               }| j                         D ]  }|j                  t        |dd               t	        t        |            S )Nrp   r)   )rG   mror   r   r   rH   )clsslotsrg   s      r"   r   zGraphNode.get_all_slots  sF      	6ALLK45	6 c%j!!r&   rj   rk   )rj   r   )rE   ztuple | dictrj   None)rj   r   r   r   r(   r   "dict[KeyType, KeyType | GraphNode]rA   r   rj   r4   )r   r4   rA   r   rj   r4   )rl   rm   rn   ro   r   rp   r   r   propertyr   rz   r   r   r   r   r   r   r   staticmethodr   classmethodr
   r   r)   r&   r"   r4   r4   q  s    	Lo&I"   " "  Y51  
 OS"6"=K"	"& 6: /
 /
b "  "r&   r4   r   _no_depsc                  x    e Zd ZU ded<    ee      Z	 d	 	 	 ddZd Zd Z	 d	 	 	 	 	 ddZ	d Z
dd	Zd
 ZddZy)r@   r   r   Nc                   t        |t              r|j                  }|| _        ||}t        |t              r|j                  }t        |t              r|j                  }|| _        t        | j                  f      | _        y r(   )r3   r?   rA   r@   r   r   r   )rc   rA   r   s      r"   rd   zAlias.__init__  sh     c7#''C>Ffe$]]Ffg&ZZF&~6r&   c                >    t         | j                  | j                  ffS r(   r@   rA   r   r   s    r"   r   zAlias.__reduce__
  s    txx---r&   c                B    t        | j                  | j                        S r(   r  r   s    r"   r   z
Alias.copy  s    TXXt{{++r&   c                   | j                   |v s| j                  |v r|j                  | j                   | j                         }|j                  | j                  | j                        }|| j                   k(  r|| j                  k(  r| S t        |t        t
        f      r|j                  i |      S |+t        |t              rt        d| j                   d|       t        |xs ||      S | S )Nr   z!Invalid substitution encountered z -> )	rA   r   getr3   r4   r?   r   r   r@   )rc   r   rA   sub_keyr   s        r"   r   zAlias.substitute  s     88tt{{d2hhtxx2G((4;;4C$(("sdkk'9#	734~~bc~22{z'9="7|4yQ  --r&   c                Z    t        |       j                  | j                  | j                  fS r(   )rU   rl   rA   r   r   s    r"   __dask_tokenize__zAlias.__dask_tokenize__!  s!    T
##TXXt{{;;r&   c                B    | j                  |       || j                     S r(   )r   r   r   s     r"   r   zAlias.__call__$  s    F#dkk""r&   c                    | j                   | j                  k7  rd| j                   d| j                  dS d| j                   dS )NzAlias(z->r   )rA   r   r   s    r"   r   zAlias.__repr__(  sB    88t{{"DHH<r$++::DHH<q))r&   c                    t        |t              sy| j                  |j                  k7  ry| j                  |j                  k(  S r   )r3   r@   rA   r   r   s     r"   r   zAlias.__eq__.  s5    %'88uyy {{ell**r&   r(   )rA   zKeyType | TaskRefr   z Alias | TaskRef | KeyType | Noner   r)   r   )rl   rm   rn   ro   r   rp   rd   r   r   r   r  r   r   r   r)   r&   r"   r@   r@     so    Oo&I RV7$7.N7., OS6=K	"<#*+r&   r@   c                      e Zd ZU ded<   ded<    ee      ZddZedd       Zd Z	ddZ
d	 Zd
 Zd Z	 d	 	 	 	 	 ddZd Zy)ru   r   r   rU   r.   c                    |$t        |      j                  t        t              f}|| _        || _        t        |      | _        t        | _        y r(   )	rU   rl   next_anom_countrA   r   r.   r  r   rc   rA   r   s      r"   rd   zDataNode.__init__;  sA    ;;''k):;C
;%r&   c                     y)NTr)   r   s    r"   r   zDataNode.data_producerC  s    r&   c                B    t        | j                  | j                        S r(   ru   rA   r   r   s    r"   r   zDataNode.copyG  s    $**--r&   c                    | j                   S r(   r   r   s     r"   r   zDataNode.__call__J  s    zzr&   c                "    d| j                   dS )Nz	DataNode(r   r  r   s    r"   r   zDataNode.__repr__M  s    4::.**r&   c                >    t         | j                  | j                  ffS r(   r  r   s    r"   r   zDataNode.__reduce__P  s    488TZZ011r&   c                \    ddl m} t        |       j                   || j                        fS Nr   r   )	dask.baser   rU   rl   r   rc   r   s     r"   r  zDataNode.__dask_tokenize__S  s#    &T
##Xdjj%9::r&   Nc                T    |%|| j                   k7  rt        || j                        S | S r(   )rA   ru   r   r   s      r"   r   zDataNode.substituteX  s)     ?sdhhC,,r&   c                ,    t        | j                        S r(   )r   r   r   s    r"   __iter__zDataNode.__iter___  s    DJJr&   )rA   r   r   r   r   r  r(   )r   r   rA   r   rj   ru   )rl   rm   rn   ro   r   rp   rd   r   r   r   r   r   r   r  r   r#  r)   r&   r"   ru   ru   6  sq    J	Io&I&  .+2; OS6=K	 r&   ru   c                   t        | t              r| j                  hS t        | t              r| j                  S t        | t
              r;| st        S  t               j                  t        t        | j                                S t        | t        t        t        t        f      r-| st        S  t               j                  t        t        |        S t        S r(   )r3   r?   rA   r4   rz   rB   r  rH   unionrV   _get_dependenciesrE   rG   r   r   )rM   s    r"   r&  r&  c  s    #wy	C	#	C	Osu{{C 13::<@AA	C$y#6	7Osu{{C 13788Or&   c                      e Zd ZU ded<   ded<   ded<   ded<   d	ed
<   ded<   d	ed<    ee      Zdd	 	 	 	 	 	 	 	 	 ddZedd       ZddZ	d Z
d Zd dZd Zd dZd!dZd Zd Zed        Z	 d"	 	 	 	 	 d#dZy)$rW   r   r   r   r+   rB   r[   rk   r   z
str | None_tokenzbool | None_is_coro_reprFr   c              V   || _         || _        t        |t              rt	        d      || _        || _        d }t        j                  ||j                               D ]  }t        |t              r,||j                   h}#|j                  |j                          ?t        |t              sP|j                  s]|t        |j                        }u|j                  |j                          |rt!        |      | _        nt$        | _        d | _        d | _        d | _        || _        y )NzCannot nest tasks)rA   r   r3   rW   r   r+   r[   r   chainrE   r?   r   r4   rz   rH   rs   r   r   r  r)  r(  r*  r   )rc   rA   r   r   r+   r[   r   r   s           r"   rd   zTask.__init__~  s     	dD!/00	-1v}}7 
	9A!W% (%&UUGM!%%aee,Ay)ann ($'$7M!((8
	9 !*=!9D!)D
,r&   c                    | j                   S r(   r+  r   s    r"   r   zTask.data_producer  s    """r&   c                (    | j                   t        k(  S r(   )r   r}   r   s    r"   has_subgraphzTask.has_subgraph  s    yy---r&   c                ~     t        |       | j                  | j                  g| j                  i | j                  S r(   )rU   rA   r   r+   r[   r   s    r"   r   z	Task.copy  s?    tDzHHII
 YY
 kk	
 	
r&   c                4    t        | j                               S r(   )r   
_get_tokenr   s    r"   r   zTask.__hash__  s    DOO%&&r&   c                    | j                   r| j                   S ddlm}  |t        |       j                  | j
                  | j                  | j                  f      | _         | j                   S r  )r(  r  r   rU   rl   r   r+   r[   r   s     r"   r3  zTask._get_token  sU    ;;;;&T
##					
 {{r&   c                "    | j                         S r(   )r3  r   s    r"   r  zTask.__dask_tokenize__  s      r&   c           	     p   t        | d      r| j                  st        | j                        }d}d}| j                  }| j
                  }|s|rZt        |t        |      z
  t        |      z
  t        t        | j                              z
  t        |      t        |      z   z        }|r!dkD  rdj                  d |D              }nd}nd}|r;dkD  r3ddj                  d	 t        |j                               D              z   }nd
}nd}d| j                  d| d| | | d	| _        | j                  S )Nr*  r   (      , c              3  2   K   | ]  }t        |        y wr(   reprr   s     r"   r7   z Task.__repr__.<locals>.<genexpr>  s     )@a$q')@r=   z... c              3  B   K   | ]  \  }}| d t        |         yw)=Nr;  r5   rN   r6   s      r"   r7   z Task.__repr__.<locals>.<genexpr>  s(      3-1Q1#QtAwi(3s   z, ...z<Task  r   >)rT   r*  r   r   r+   r[   r   r   r   rA   joinr   rC   )	rc   headtail
label_sizer+   r[   label_size2	args_reprkwargs_reprs	            r"   r   zTask.__repr__  s)    tW%TZZDII&DDJ99D[[Fv!#d)+c$i7#c$((m:LLD	CK/1 ? $		)@4)@ @I %I	?"& 35;FLLN5K3 * #K #*K !$((QtfAi[dVSTUDJzzr&   c                :   | j                         fd}t        t        || j                              }| j                  rE| j                  j                         D ci c]  \  }}| ||       }}} | j                  |i |S  | j                  | S c c}}w )Nc                    t        | t              r$ | | j                  D ci c]  }||   
 c}      S t        | t              r| j                     S | S c c}w r(   )r3   r4   rz   r?   rA   )r   rN   rE   s     r"   _evalzTask.__call__.<locals>._eval  sR    !Y'?1!VAY,?@@Aw'aee}$	 @s   A)r   r   rV   r+   r[   rC   r   )rc   rE   rL  new_argspecrN   kwr[   s    `     r"   r   zTask.__call__  s    F#	 Ctyy12;;040A0A0CDuq"arlDFD499k4V44tyy+&& Es    Bc                z    | j                   j                         }t        ||      D ]  \  }}t        | ||        y r(   )	__class__r   rt   setattr)rc   stater   r   r   s        r"   __setstate__zTask.__setstate__  s:    ,,.5%( 	#GBD"c"	#r&   c                `      j                   j                         }t         fd|D              S )Nc              3  6   K   | ]  }t        |        y wr(   )r   r   s     r"   r7   z$Task.__getstate__.<locals>.<genexpr>   s     72WT2&7s   )rP  r   r   )rc   r   s   ` r"   __getstate__zTask.__getstate__  s&    ,,.7777r&   c                    | j                   *	 ddlm}  || j                        | _         | j                   S | j                   S # t        $ r d| _         Y | j                   S w xY w)Nr   )iscoroutinefunctionF)r)  distributed.utilsrX  r   	Exception)rc   rX  s     r"   r   zTask.is_coro  s[    == &A 3DII > }}t}}  & %}}&s   A A! A!Nc           
       
 |j                         D ci c]  \  }}|| j                  v s||k7  s|| c}}
t        t        |             }|D ci c]  }|dvs|t	        | |       }}
rt        
fd| j                  D              }| j                  j                         D ci c]/  \  }}|t        |t        t        f      r|j                  
      n|1 }	}} t        |       |xs | j                  | j                  g|i |	|S ||| j                  k(  r| S  t        |       || j                  g| j                  i | j                  |S c c}}w c c}w c c}}w )N>   rA   r   c              3  p   K   | ]-  }t        |t        t        f      r|j                        n| / y wr(   r3   r4   r?   r   r5   r   subs_filtereds     r"   r7   z"Task.substitute.<locals>.<genexpr>  s=        "!i%9: LL/   36)rC   rz   _extra_argsrU   r   r   r+   r[   r3   r4   r?   r   rA   r   )rc   r   rA   rN   r6   extrasnameextra_kwargsrZ   
new_kwargsr_  s             @r"   r   zTask.substitute  s    "ZZ\
QQ$2C2C-CQAqD
 T$Z(28
*.D<WD'$%%
 
    H !KK--/ Aq !!i%9: LL/J  4:txx		  	
   [C488OK 4:		  ++	
  G

s!   EEE	E!E!+4E&)
rA   r   r   r   r+   r   r   rk   r[   r   r   )rj   r   r  r(   )r   r   rA   r   rj   rW   )rl   rm   rn   ro   r   rp   rd   r   r   r0  r   r   r3  r  r   r   rS  rV  r   r   r)   r&   r"   rW   rW   s  s    
N
KLo&I  %#-#- #-
 #- #- #-J # #.
'!B'"#
8 	 	 OS,6,=K,	,r&   rW   c                       e Zd ZU ded<   ded<    ee      Z	 	 	 	 d fdZ fdZ fdZd Z		 d	 	 	 	 	 dd	Z
 fd
Zed        Zd Z xZS )NestedContainerr   constructorrU   klassc                   t        |      dk(  rt        |d   | j                        r|d   }t        |   d | j
                  g|d| j                  i| y )Nr   r   rh  )r   r3   ri  superrd   to_containerrh  rc   r+   r[   rP  s      r"   rd   zNestedContainer.__init__B  sg     t9>ja$**=7D	
 	
 ((		

 	
r&   c                    t         |          }t        |      }| j                  j	                         }|j                  d      }||   j                         ||<   ||   j                  dd        |S )Nr[   rh  )rk  rV  rG   rP  r   indexr   r   )rc   rR  r   ixrP  s       r"   rV  zNestedContainer.__getstate__R  sf    $&U,,.[[" "INN$b	b	mT*r&   c                l    t         |   |       | j                  j                  | j                  d<   | S )Nrh  )rk  rS  rP  rh  r[   )rc   rR  rP  s     r"   rS  zNestedContainer.__setstate__^  s-    U#%)^^%?%?M"r&   c                L    t        |       j                   d| j                   dS r   )rU   rl   r+   r   s    r"   r   zNestedContainer.__repr__c  s$    t*%%&a		{!44r&   c                    |j                         D ci c]  \  }}|| j                  v s||k7  s|| c}}s| S  t        |       fd| j                  D         S c c}}w )Nc              3  p   K   | ]-  }t        |t        t        f      r|j                        n| / y wr(   r]  r^  s     r"   r7   z-NestedContainer.substitute.<locals>.<genexpr>o  s=        "!i%9: LL/r`  )rC   rz   rU   r+   )rc   r   rA   rN   r6   r_  s        @r"   r   zNestedContainer.substitutef  sp     "ZZ\
QQ$2C2C-CQAqD
 KtDz 	
 		

s   A A A c                    ddl m t        |       j                  | j                  t        fd| j                  D              fS )Nr   r   c              3  .   K   | ]  } |        y wr(   r)   )r5   r   r   s     r"   r7   z4NestedContainer.__dask_tokenize__.<locals>.<genexpr>  s     218A;2s   )	r   r   rU   rl   ri  r   r+   rk  r  )rc   r   rP  s    @r"   r  z!NestedContainer.__dask_tokenize__y  s8    * JJJ2		22
 	
r&   c                     | |      S r(   r)   )rh  r+   s     r"   rl  zNestedContainer.to_container  s    4  r&   c              #  8   K   | j                   E d {    y 7 wr(   r*   r   s    r"   r#  zNestedContainer.__iter__  s     99s   r+   r   r[   r   r(   )r   r   rA   r   rj   rg  )rl   rm   rn   ro   r   rp   rd   rV  rS  r   r   r  r   rl  r#  __classcell__rP  s   @r"   rg  rg  =  s    Ko&I
 
 	
 

5 OS
6
=K
	
&	+ ! !r&   rg  c                      e Zd ZexZZy)rI   N)rl   rm   rn   rG   rh  ri  r)   r&   r"   rI   rI     s    K%r&   rI   c                      e Zd ZexZZy)rL   N)rl   rm   rn   r   rh  ri  r)   r&   r"   rL   rL     s    K%r&   rL   c                      e Zd ZexZZy)rJ   N)rl   rm   rn   rH   rh  ri  r)   r&   r"   rJ   rJ     s    K%r&   rJ   c                  b     e Zd ZeZd fdZd Z	 d		 	 	 	 	 d
dZd Zd Z	d Z
ed        Z xZS )rF   c                  |r|rJ t        |      dk(  r|d   }t        |t              r*t        t	        j
                  |j                                }nOt        |t        t        f      r.t        d |D              r't        t	        j
                  |       }nt        d      t        |      dz  dk7  r:t        d      |r-|rJ t        t	        j
                  |j                                }t        | ,  |  y )Nr   r   c              3  h   K   | ]*  }t        |t        t        f      rt        |      d k(  nd , yw)   FN)r3   rG   r   r   )r5   els     r"   r7   z Dict.__init__.<locals>.<genexpr>  s2       )32e}(EB15Ps   02zInvalid argument providedr  z$Invalid number of arguments provided)r   r3   rB   r   r   r-  rC   rG   allr   rk  rd   rm  s      r"   rd   zDict.__init__  s    :4yA~AwdD) $**,!?@DtUm4 "&   %Y__d%;<$%@AA4y1}! !GHHO8&,,.9:D$r&   c                j    dj                  d t        | j                  dd      D              }d| dS )Nr9  c              3  0   K   | ]  \  }}| d |   yw)z: Nr)   r@  s      r"   r7   z Dict.__repr__.<locals>.<genexpr>  s     V41aaS1#;Vs   r  Tr   zDict(r   )rC  r%   r+   r   s     r"   r   zDict.__repr__  s3    V7499aPT3UVVvha  r&   c                B   |j                         D ci c]  \  }}|| j                  v s||k7  s|| }}}|s| S g }| j                  D ]<  }t        |t        t
        f      r|j                  |      n|}|j                  |       >  t        |       |      S c c}}w r(   )	rC   rz   r+   r3   r4   r?   r   r   rU   )	rc   r   rA   rN   r6   r_  rZ   r   new_args	            r"   r   zDict.substitute  s     "ZZ\
QQ$2C2C-CQAqD
 
 K99 	%C cIw#78 }- 
 OOG$	% tDz(##
s   BBBc              #  D   K   | j                   d d d   E d {    y 7 wNr  r*   r   s    r"   r#  zDict.__iter__  s     99SqS>!!s     c                2    t        | j                        dz  S r  )r   r+   r   s    r"   __len__zDict.__len__  s    499~""r&   c                j    t        | j                  dd      D ]  \  }}||k(  s|c S  t        |      Nr  Tr   )r%   r+   KeyError)rc   rA   rN   r6   s       r"   __getitem__zDict.__getitem__  s:    DIIq6 	DAqCx	 smr&   c                0    t        t        | dd            S r  )rB   r%   r*   s    r"   rh  zDict.constructor  s    GD!D122r&   ry  r(   )r   r   rA   r   rj   rF   )rl   rm   rn   rB   ri  rd   r   r   r#  r  r  r   rh  rz  r{  s   @r"   rF   rF     sY    E 2!
 OS$6$=K$	$&"# 3 3r&   rF   c                  6    e Zd Zd Zd Zd ZddZd	dZd
dZy)DependenciesMappingc                    || _         t               | _        |j                         | _        | j                  j                          y r(   )r   rH   _removedr   _cacheclear)rc   r   s     r"   rd   zDependenciesMapping.__init__  s/    hhjr&   c                "   | j                   j                  |      x}|S | j                  |   }	 |j                  }| j                  r|| j                  z
  }|| j                   |<   |S # t        $ r ddlm}  || j                  |      }Y Qw xY w)Nr   )get_dependencies)r   )r  r	  r   rz   AttributeError	dask.corer  r  )rc   rA   r   r6   depsr  s         r"   r  zDependenciesMapping.__getitem__  s    ;;??3''C4JA:~~ }} dmm+#DKKK " :6'q9:s   A( (#BBc                ,    t        | j                        S r(   )r   r   r   s    r"   r#  zDependenciesMapping.__iter__  r   r&   c                n    | j                   j                          | j                  j                  |       y r(   )r  r  r  r   r   s     r"   __delitem__zDependenciesMapping.__delitem__  s$    #r&   c                    t         r(   r   r  s      r"   __setitem__zDependenciesMapping.__setitem__  r   r&   c                ,    t        | j                        S r(   )r   r   r   s    r"   r  zDependenciesMapping.__len__  r   r&   N)rA   r   rj   r   )rA   r   r   r   rj   r   r   )	rl   rm   rn   rd   r  r#  r  r  r  r)   r&   r"   r  r    s     &"r&   r  c                  *    e Zd Zd Zd Zd Zd Zd Zy)_DevNullMappingc                    t        |      r(   )r  r   s     r"   r  z_DevNullMapping.__getitem__  s    smr&   c                     y r(   r)   r  s      r"   r  z_DevNullMapping.__setitem__	      r&   c                     y r(   r)   r   s     r"   r  z_DevNullMapping.__delitem__  r  r&   c                     yNr   r)   r   s    r"   r  z_DevNullMapping.__len__  s    r&   c                    t        d      S )Nr)   )r   r   s    r"   r#  z_DevNullMapping.__iter__  s    Bxr&   N)rl   rm   rn   r  r  r  r  r#  r)   r&   r"   r  r    s    r&   r  c                   t        | t        t        t        t        f      r| D ci c]  }|j
                  | } }nt        | t              sJ t        t              }t        |       j                         D ]  }|D ]  }||xx   dz  cc<     |xs i }ddlm}  ||       t        | j                         fd      D ]B  \  }}	 |	|      ||<   |	j                  D ]#  }
||
xx   dz  cc<   ||
   dk(  s|s|
|vs!||
= % D |S c c}w )a  Execute a given graph.

    The graph is executed in topological order as defined by dask.order until
    all leaf nodes, i.e. nodes without any dependents, are reached. The returned
    dictionary contains the results of the leaf nodes.

    If keys are required that are not part of the graph, they can be provided in the `cache` argument.

    If `keys` is provided, the result will contain only values that are part of the `keys` set.

    r   r   )orderc                    | d      S r  r)   )r    
prioritiess    r"   <lambda>zexecute_graph.<locals>.<lambda>5  s    
2a58I r&   r   )r3   rG   r   rH   r   rA   rB   r   r   r  rE   
dask.orderr  r   rC   rz   )r   cacherr   r   refcountvalsr   r  rA   nodedepr  s              @r"   rv   rv     s     #eS)45!$%Aquuax%%#t$$$*5c*:H#C(//1  	CSMQM	 KRE sJCIIK-IJ 	T%[c
$$ 	CSMQM}!ds$#J	 L+ &s   D	c                8   ddl m} ddlm} t	        |      }t        |       } ||      }t	               }i }| D ]  }||v r	|j                  |       ||   }	||   }
t        |	      dk7  rt        |
      dk7  s| |   j                  r	| |   ||<   X| |   g}|}t        |	      dk(  ru|	\  }||v rnl|j                  |       || vrnVt        ||         dk7  s| |   j                  s||v r	| |   ||<   n)|j                  d| |          ||   }	t        |	      dk(  rut        |
      dk(  r||vr}|
j                         }||v rnh|j                  |       t        ||         dk7  s| |   j                  r	| |   ||<   n.|j                  | |          |}||   }
t        |
      dk(  r||vr}t        |      dk(  r
|d   ||<    ||D cg c]  }|j                   c}      }t        j                  |d|i||<   ||k7  st        ||      ||<    |S c c}w )zq
    keys are the keys from the graph that are requested by a computation. We
    can't fuse those together.
    r   )reverse_dict)default_fused_keys_renamerr   rA   r   )r  r  dask.optimizationr  rH   r  r   r   r   insertr   r   rA   rW   r   r@   )r   rr   r  r  rz   r   r   resultrA   r  dependents_keylinear_chaintop_keynew_keytskrenamed_keys                   r"   fuse_linear_task_specr  ?  s^   
 '<t9D&s+Ll+J5DF @E$;C #Ct9>c.1Q6#c(:O:Oc(F3KCz
 $i1nJW$HHWc! Jw'(A-w<,,d?"%g,w3w<0(D' $i1n0 .!Q&7$+>$((*G$HHW<()Q.#g,2K2K"%g,wG-G'0N .!Q&7$+> |!*1oF7O 55V#cgg5VWK"&))\"K{"KF;g%"'"DwA@EB M 6Ws   	H
c                   t        |t        t        t        f      s!t	        dt        |      j                         t        |      t        |       k(  r| S t        |      }t               }i }|j                  }|j                  }|j                  }|r7 |       }||v s|| vr ||       | |   x||<   }	 ||	j                         |r7|S )Nz*Expected list, set or tuple for keys, got )r3   rG   rH   r   r   rU   rl   r   r   rs   r   rz   )
r   rr   r   r   dsk2wpopwupdatesaddrN   r6   s
             r"   cullr    s     dT3./8d9L9L8MN
 	
 4yCH
t9DDD88DkkG88D
F9Q!fQ!  Kr&   c                B   dd l }|j                  |       }t               }|j                  j	                         D ]b  \  }}|j
                  |j                  j                  |j                  j                  fv r?|| j                         v sR|j                  |       d |S r  )inspect	signaturerH   
parametersrC   kind	ParameterVAR_POSITIONALVAR_KEYWORDr   r   )r.   r  sigrb  rc  params         r"   ra  ra    s    


C
 CUF~~++- e::,,))
 
 3$$&&JJt Mr&   )rM   r   rj   ri   )rA   r   r   r   r   r   rj   zGraphNode | _Tr(   )r   r   r   zContainer | None)r   rB   rr   rH   r   rB   rj   rB   )rM   ri   rj   zset | frozenset)NN)r   z1Iterable[GraphNode] | Mapping[KeyType, GraphNode]r  z&MutableMapping[KeyType, object] | Nonerr   zContainer[KeyType] | Nonerj   zMutableMapping[KeyType, object])r   dict[KeyType, GraphNode]rr   zIterable[KeyType]rj   r  )r.   rU   rj   zset[str])B
__future__r   	functoolsr   r   collectionsr   collections.abcr   r   r   r   r	   r
   r   typingr   r   r   dask.sizeofr   dask.typingr   r   
dask.utilsr   r   r   r#   
hexversionr%   __doc__r,   r/   countr  r:   rK   rX   r_   SubgraphTyper}   r   r   r   r?   r4   r   r  ro   r@   ru   r&  rW   rg  rI   rL   rJ   rF   r  r  rv   r  r  r  ra  r)   r&   r"   <module>r     s   "5l   
 # R R ( % %  & 7T]
 %* ( >>Y', = G&&GO ioo)X 3i 3 5	5
5 5 	5t "&	"6r! !H@" @"F  k) !<+I <+~* y * Z G9 GTLdH L^?  O  / A3?G A3H&. &Rn & 59&*&	:&1& $& %	&RPf	!):2  r&   