>ie51 ddlmZddlmZddlmZmZdZdZGddZ Gdd Z e d Z e d Z Gd d e ZGddZGddZdZdZeedZdZdZdS)) annotations)deque)istasksubsclt|r|dSt|trtS|S)z#Return the top level node of a taskrr isinstancelisttasks ,lib/python3.11/site-packages/dask/rewrite.pyheadrs7d||Aw D$    cft|r |ddSt|tr|SdS)z&Get the arguments for the current taskNrr s r argsrs;d||ABBx D$   rrcHeZdZdZd dZdZdZdZedZ dZ dS) 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`. Nc^||_|sttg|_dS||_dSN)termrEND_stack)selfrstacks r __init__zTraverser.__init__2s/  ,,DKKKDKKKrc#K|jtur-|jV||jtu+dSdSr)currentrnextrs r __iter__zTraverser.__iter__9sIl#%%,    IIKKKl#%%%%%%rcPt|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$+$6$6777rct|j}|s |j|_dS|d|_|jt |dddS)z3Proceed to the next term in the preorder traversal.rrN)rrrpopextendreversed)rsubtermss r r zTraverser.nextFsg ?? 7 ))DIII  DI K  x 55 6 6 6 6 6rc*t|jSr)rrr!s r rzTraverser.currentQsDIrcB|j|_dS)zNNrr3?endcJeZdZdZdZddZedZedZdS)NodezA Discrimination Net node.rNcT|r|ni}|r|ng}t|||fSr)tuple__new__)clsedgespatternss r r?z Node.__new__rs7&B'/88R}}S5("3444rc|dS)z@A dictionary, where the keys are edges, and the values are nodesrrr!s r rAz Node.edgesw Awrc|dS)z8A list of all patterns that currently match at this noderrr!s r rBz Node.patterns|rDr)NN) r-r.r/r0 __slots__r?r1rArBrrr r<r<msi$$I5555 XXrr<c,eZdZdZddZdZdZdZdS) RewriteRulea A rewrite rule. Expresses `lhs` -> `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) rcXttstd||_t |r||_n |j|_||_fdt|D|_ ttt|j |_ dS)Nz!vars must be a tuple of variablescg|]}|v| Srr).0tvarss r z(RewriteRule.__init__..s@@@qa4iiiiir) r r> TypeErrorlhscallabler_applyrhsr_varlistsortedsetrM)rrPrSrMs `r rzRewriteRule.__init__s$&& A?@@ @ C== $DII DI@@@@IcNN@@@ &T]!3!34455 rcj|j}|D]\}}t|||}|Sr)rSitemsr)rsub_dictrkeyvals r rRzRewriteRule._applys>x (( ( (HCc3''DD rc8d|jd|jd|jdS)Nz RewriteRule(z, ))rPrSrMr!s r __str__zRewriteRule.__str__s)BdhBB$(BBdiBBBBrc t|Sr)strr!s r r8zRewriteRule.__repr__s4yyrN)r)r-r.r/r0rrRr^r8rrr rHrHsc++Z 6 6 6 6 CCCrrHc2eZdZdZdZdZdZdZd dZdS) 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`. cnt|_g|_|D]}||dS)zCreate a `RuleSet` for a number of rules Parameters ---------- rules One or more instances of RewriteRule N)r<_netrulesadd)rreps r rzRuleSet.__init__s@FF    A HHQKKKK  rct|tstd|j}|j}t |j}t|jD]I}|}||vrt}||j vr|j |}&t|j |<|j |}J|j |j ||j |dS)zeAdd a rule to the RuleSet. Parameters ---------- rule : RewriteRule z$rule must be instance of RewriteRuleN)r rHrOrMrdlenrerrPVARrAr<rBappend)rrulerM curr_nodeindrL prev_nodes r rfz RuleSet.adds$ ,, DBCC CyI $*oo48$$ / /A!IDyyIO##%OA. %)VV "%OA. #**3/// $rc#Kt|}t||jD]/\}}|D]'}|j|}t ||}|||fV(0dS)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_matchrdre_process_match)rrSmsymsirlrs r iter_matcheszRuleSet.iter_matchess dOOa++ % %GAt % %z!}%dD11#*$$$  % % %rcf||D]\}}||}|S)z7Apply the rewrite rules in RuleSet to top level of term)rwr)rrrlsds r _rewritezRuleSet._rewrite0s>))$//  HD"99R==D  r bottom_upc.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)r{) r-r.r/r0rrfrwrzrrrr rbrbso&&P      6%%%*   )0)0)0)0)0)0rrbc,||Sr)rznetrs r _top_levelrgs <<  rc t|r:t|ftfdt|Dz}n0t |t rfdt|D}|S)Nc38K|]}t|VdSr _bottom_uprKrLrs r z_bottom_up..ms-$L$LAZQ%7%7$L$L$L$L$L$Lrc0g|]}t|Srrrs r rNz_bottom_up..os#777q 3""777r)rrr>rr r rzrs` r rrks d||8T }u$L$L$L$Ld$L$L$LLLL D$  87777DJJ777 <<  r) top_levelr{c#6Kt}d}d} |jtur |j|fV |j|jd}|rC|sA||||f|}|n#t$rYnwxYw|jtd}|r$d}||j fz}| |} | \}}}d}n#t$rYdSwxYw)z;Structural matching of term S to discrimination net node N.FrTN)rrrrBrAgetrkr$r rOrjrr,r& Exception)rsNrrestore_state_flagmatchesns r rqrqvsV GGEG 9  *g% % % %  AIt,,A +  affhh73444    D  GKKT " "  !&  )G FFHHHA  #iikkOQ7!%      FF 5s$A$B B#"B#-D DDci}|j}t|t|kstdt||D]\}}||vr|||krdS|||<|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)rTri RuntimeErrorzip)rlrurvarlistvss r rrrrs DmG w<<3t99 $ $LMMMGT""1 99aA44DGG KrN) __future__r collectionsr dask.corerrrrrr3rjrr>r<rHrbrrr}rqrrrrr rs""""""""""""""9&9&9&9&9&9&9&9&x         eCjj eEll5*EEEEEEEEPZ0Z0Z0Z0Z0Z0Z0Z0z&J ? ? ###Lr