Lg51ddlmZddlmZddlmZmZdZdZGddZ Gdd Z e d Z e d Z Gd d e ZGddZGddZdZdZeedZdZdZy)) annotations)deque)istasksubscRt|r|dSt|trtS|S)z#Return the top level node of a taskrr isinstancelisttasks ,lib/python3.12/site-packages/dask/rewrite.pyheadrs(d|Aw D$   cHt|r|ddSt|tr|Sy)z&Get the arguments for the current taskNrr s r argsrs(d|ABx D$  rc@eZdZdZd dZdZdZdZedZ dZ y) TraverseraTraverser interface for tasks. Class for storing the state while performing a preorder-traversal of a task. Parameters ---------- term : task The task to be traversed Attributes ---------- term The current element in the traversal current The head of the current element in the traversal. This is simply `head` applied to the attribute `term`. NcP||_|sttg|_y||_yN)termrEND_stack)selfrstacks r __init__zTraverser.__init__2s  ,DKDKrc#K|jtur2|j|j|jtur1yywr)currentrnextrs r __iter__zTraverser.__iter__9s3ll#%,,  IIKll#%s AAAcTt|jt|jS)zCopy the traverser in its current state. This allows the traversal to be pushed onto a stack, for easy backtracking.)rrrrr!s r copyzTraverser.copy>s E$++$677rct|j}|s |jj|_y|d|_|jj t |ddy)z3Proceed to the next term in the preorder traversal.rrN)rrrpopextendreversed)rsubtermss r r zTraverser.nextFsN ? )DI  DI KK  x 5 6rc,t|jSr)rrr!s r rzTraverser.currentQsDIIrcB|jj|_y)z `rhs`, for variables `vars`. Parameters ---------- lhs : task The left-hand-side of the rewrite rule. rhs : task or function The right-hand-side of the rewrite rule. If it's a task, variables in `rhs` will be replaced by terms in the subject that match the variables in `lhs`. If it's a function, the function will be called with a dict of such matches. vars: tuple, optional Tuple of variables found in the lhs. Variables can be represented as any hashable object; a good convention is to use strings. If there are no variables, this can be omitted. Examples -------- Here's a `RewriteRule` to replace all nested calls to `list`, so that `(list, (list, 'x'))` is replaced with `(list, 'x')`, where `'x'` is a variable. >>> import dask.rewrite as dr >>> lhs = (list, (list, 'x')) >>> rhs = (list, 'x') >>> variables = ('x',) >>> rule = dr.RewriteRule(lhs, rhs, variables) Here's a more complicated rule that uses a callable right-hand-side. A callable `rhs` takes in a dictionary mapping variables to their matching values. This rule replaces all occurrences of `(list, 'x')` with `'x'` if `'x'` is a list itself. >>> lhs = (list, 'x') >>> def repl_list(sd): ... x = sd['x'] ... if isinstance(x, list): ... return x ... else: ... return (list, x) >>> rule = dr.RewriteRule(lhs, repl_list, variables) cFt|ts td||_t |r||_n|j |_||_t|Dcgc] }||vs| c}|_ ttt|j|_ ycc}w)Nz!vars must be a tuple of variables) r r> TypeErrorlhscallabler_applyrhsr_varlistsortedsetvars)rrKrNrRts r rzRewriteRule.__init__s$&?@ @ C=DI DI$-cN@Nqa4iN@ &T]]!345 As  B%Bch|j}|jD]\}}t|||}|Sr)rNitemsr)rsub_dictrkeyvals r rMzRewriteRule._applys3xx (HCc3'D) rcVd|jd|jd|jdS)Nz RewriteRule(z, ))rKrNrRr!s r __str__zRewriteRule.__str__s)dhhZr$((2dii[BBrct|Sr)strr!s r r8zRewriteRule.__repr__s 4yrN)r)r-r.r/r0rrMr[r8rrr rHrHs+Z 6 CrrHc0eZdZdZdZdZdZdZddZy) RuleSeta%A set of rewrite rules. Forms a structure for fast rewriting over a set of rewrite rules. This allows for syntactic matching of terms to patterns for many patterns at the same time. Examples -------- >>> import dask.rewrite as dr >>> def f(*args): pass >>> def g(*args): pass >>> def h(*args): pass >>> from operator import add >>> rs = dr.RuleSet( ... dr.RewriteRule((add, 'x', 0), 'x', ('x',)), ... dr.RewriteRule((f, (g, 'x'), 'y'), ... (h, 'x', 'y'), ... ('x', 'y'))) >>> rs.rewrite((add, 2, 0)) 2 >>> rs.rewrite((f, (g, 'a', 3))) # doctest: +ELLIPSIS (, 'a', 3) >>> dsk = {'a': (add, 2, 0), ... 'b': (f, (g, 'a', 3))} >>> from toolz import valmap >>> valmap(rs.rewrite, dsk) # doctest: +ELLIPSIS {'a': 2, 'b': (, 'a', 3)} Attributes ---------- rules : list A list of `RewriteRule`s included in the `RuleSet`. c`t|_g|_|D]}|j|y)zCreate a `RuleSet` for a number of rules Parameters ---------- rules One or more instances of RewriteRule N)r<_netrulesadd)rrbps r rzRuleSet.__init__s)F  A HHQKrct|ts td|j}|j}t |j }t|jD]R}|}||vrt}||jvr|j|}-t|j|<|j|}Tjjj||j j|y)zeAdd a rule to the RuleSet. Parameters ---------- rule : RewriteRule z$rule must be instance of RewriteRuleN)r rHrJrRralenrbrrKVARrAr<rBappend)rrulerR curr_nodeindrS prev_nodes r rcz RuleSet.adds$ ,BC CyyII $**o488$A!IDyIOO#%OOA. %)V "%OOA. % ##**3/ $rc#Kt|}t||jD]0\}}|D]&}|j|}t ||}|!||f(2yw)alA generator that lazily finds matchings for term from the RuleSet. Parameters ---------- term : task Yields ------ Tuples of `(rule, subs)`, where `rule` is the rewrite rule being matched, and `subs` is a dictionary mapping the variables in the lhs of the rule to their matching values in the term.N)r_matchrarb_process_match)rrSmsymsirirs r iter_matcheszRuleSet.iter_matchess] dOa+GAtzz!}%dD1#*$ ,s A A Ac^|j|D]\}}|j|}|S|S)z7Apply the rewrite rules in RuleSet to top level of term)rtr)rrrisds r _rewritezRuleSet._rewrite0s;))$/HD"99R=D  0  rc t|||S)aeApply the `RuleSet` to `task`. This applies the most specific matching rule in the RuleSet to the task, using the provided strategy. Parameters ---------- term: a task The task to be rewritten strategy: str, optional The rewriting strategy to use. Options are "bottom_up" (default), or "top_level". Examples -------- Suppose there was a function `add` that returned the sum of 2 numbers, and another function `double` that returned twice its input: >>> add = lambda x, y: x + y >>> double = lambda x: 2*x Now suppose `double` was *significantly* faster than `add`, so you'd like to replace all expressions `(add, x, x)` with `(double, x)`, where `x` is a variable. This can be expressed as a rewrite rule: >>> rule = RewriteRule((add, 'x', 'x'), (double, 'x'), ('x',)) >>> rs = RuleSet(rule) This can then be applied to terms to perform the rewriting: >>> term = (add, (add, 2, 2), (add, 2, 2)) >>> rs.rewrite(term) # doctest: +SKIP (double, (double, 2)) If we only wanted to apply this to the top level of the term, the `strategy` kwarg can be set to "top_level". >>> rs.rewrite(term) # doctest: +SKIP (double, (add, 2, 2)) ) strategies)rr strategys r rewritezRuleSet.rewrite;sR(#D$//rN) bottom_up) r-r.r/r0rrcrtrwr{rrr r_r_s!&P  6%* )0rr_c$|j|Sr)rw)netrs r _top_levelrgs << rct|r+t|ftfdt|Dz}n2t |t r"t|Dcgc]}t |}}j|Scc}w)Nc36K|]}t|ywr) _bottom_up).0rSr~s r z_bottom_up..ms$LAZQ%7s)rrr>rr r rrw)r~rrSs` r rrksf d|T }u$Ld$LLL D$ ,0J7Jq 3"J7 << 8sA;) top_levelr|c#&Kt}d}d} |jtur|j|f |jj |jd}|r7|s5|j |j||f|}|j|jj td}|r%d}||jfz}|j|} |j\}}}d}#t$rYjwxYw#t$rYywxYww)z;Structural matching of term S to discrimination net node N.FrTN)rrrrBrAgetrhr$r rJrgrr,r& Exception)rpNrrestore_state_flagmatchesns r rnrnvs GEG  99 **g% %  AIIt,A+ affh734 GGKKT " !&  )G FFHA  #iikOQ7!% 3       sN2DAC3ADD2D3 C?<D>C??D D D DDci}|j}t|t|k(s tdt||D]\}}||vr |||k7ry|||<|S)aProcess a match to determine if it is correct, and to find the correct substitution that will convert the term into the pattern. Parameters ---------- rule : RewriteRule syms : iterable Iterable of subterms that match a corresponding variable. Returns ------- A dictionary of {vars : subterms} describing the substitution to make the pattern equivalent with the term. Returns `None` if the match is invalid.z/length of varlist doesn't match length of syms.N)rOrf RuntimeErrorzip)rirrrvarlistvss r rorosg DmmG w<3t9 $LMMGT"1 9aADG # KrN) __future__r collectionsr dask.corerrrrrr3rgrr>r<rHr_rrryrnrorrr rs""9&9&x   Cj El5*EEPZ0Z0z&J ? #Lr