B ÛT•\µ1ã@sÎddlmZmZmZddlmZddlmZmZdd„Z dd„Z Gdd „d e ƒZ Gd d „d e ƒZ e d ƒZe d ƒZGdd„deƒZGdd„de ƒZGdd„de ƒZdd„Zdd„ZeedœZdd„Zdd„ZdS)é)Úabsolute_importÚdivisionÚprint_function)Údeque)ÚistaskÚsubscCs&t|ƒr|dSt|tƒrtS|SdS)z#Return the top level node of a taskrN)rÚ isinstanceÚlist)Útask©r ú+lib/python3.7/site-packages/dask/rewrite.pyÚheads  r cCs*t|ƒr|dd…St|tƒr"|SdSdS)z&Get the arguments for the current taskéNr )rrr )r r r r Úargss   rc@sFeZdZdZddd„Zdd„Zdd„Zd d „Zed d „ƒZ d d„Z dS)Ú Traversera£Traverser 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`. NcCs"||_|sttgƒ|_n||_dS)N)ÚtermrÚENDÚ_stack)ÚselfrÚstackr r r Ú__init__2szTraverser.__init__ccs$x|jtk r|jV| ¡qWdS)N)ÚcurrentrÚnext)rr r r Ú__iter__9s zTraverser.__iter__cCst|jt|jƒƒS)z…Copy the traverser in its current state. This allows the traversal to be pushed onto a stack, for easy backtracking.)rrrr)rr r r Úcopy>szTraverser.copycCsBt|jƒ}|s|j ¡|_n"|d|_|j t|dd…ƒ¡dS)z3Proceed to the next term in the preorder traversal.rrN)rrrÚpopÚextendÚreversed)rZsubtermsr r r rFs   zTraverser.nextcCs t|jƒS)N)r r)rr r r rQszTraverser.currentcCs|j ¡|_dS)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. >>> lhs = (list, (list, 'x')) >>> rhs = (list, 'x') >>> variables = ('x',) >>> rule = 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 = RewriteRule(lhs, repl_list, variables) r csftˆtƒstdƒ‚||_t|ƒr(||_n|j|_||_‡fdd„t|ƒDƒ|_ tt t |j ƒƒƒ|_ dS)Nz!vars must be a tuple of variablescsg|]}|ˆkr|‘qSr r )Ú.0Út)Úvarsr r ú ¸sz(RewriteRule.__init__..) rr*Ú TypeErrorÚlhsÚcallablerÚ_applyÚrhsrÚ_varlistÚsortedÚsetr3)rr6r9r3r )r3r r¯s zRewriteRule.__init__cCs,|j}x | ¡D]\}}t|||ƒ}qW|S)N)r9Úitemsr)rZsub_dictrÚkeyÚvalr r r r8¼szRewriteRule._applycCsd |j|j|j¡S)NzRewriteRule({0}, {1}, {2}))Úformatr6r9r3)rr r r Ú__str__Âs zRewriteRule.__str__cCst|ƒS)N)Ústr)rr r r r&ÆszRewriteRule.__repr__N)r )rr r!r"rr8rAr&r r r r r0‚s + r0c@s:eZdZdZdd„Zdd„Zdd„Zdd „Zdd d „Zd S)Ú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 -------- >>> def f(*args): pass >>> def g(*args): pass >>> def h(*args): pass >>> from operator import add >>> rs = RuleSet( # Make RuleSet with two Rules ... RewriteRule((add, 'x', 0), 'x', ('x',)), ... RewriteRule((f, (g, 'x'), 'y'), ... (h, 'x', 'y'), ... ('x', 'y'))) >>> rs.rewrite((add, 2, 0)) # Apply ruleset to single task 2 >>> rs.rewrite((f, (g, 'a', 3))) # doctest: +SKIP (h, 'a', 3) >>> dsk = {'a': (add, 2, 0), # Apply ruleset to full dask graph ... 'b': (f, (g, 'a', 3))} >>> from toolz import valmap >>> valmap(rs.rewrite, dsk) # doctest: +SKIP {'a': 2, 'b': (h, 'a', 3)} Attributes ---------- rules : list A list of `RewriteRule`s included in the `RuleSet`. cGs*tƒ|_g|_x|D]}| |¡qWdS)z—Create a `RuleSet` for a number of rules Parameters ---------- rules One or more instances of RewriteRule N)r)Ú_netÚrulesÚadd)rrEÚpr r r rós zRuleSet.__init__cCsšt|tƒstdƒ‚|j}|j}t|jƒ}xNt|jƒD]@}|}||krHt }||j kr^|j |}q4t ƒ|j |<|j |}q4W|j |j   |¡|j  |¡dS)zeAdd a rule to the RuleSet. Parameters ---------- rule : RewriteRule z$rule must be instance of RewriteRuleN)rr0r5r3rDÚlenrErr6ÚVARr-r)r.Úappend)rÚruler3Z curr_nodeZindr2Z prev_noder r r rFs     z RuleSet.addccsZt|ƒ}xLt||jƒD]<\}}x2|D]*}|j|}t||ƒ}|dk r$||fVq$WqWdS)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)rrÚSÚmÚsymsÚirKrr r r Ú iter_matchess    zRuleSet.iter_matchescCs(x"| |¡D]\}}| |¡}Pq W|S)z7Apply the rewrite rules in RuleSet to top level of term)rRr)rrrKZsdr r r Ú_rewrite0s zRuleSet._rewriteÚ bottom_upcCst|||ƒ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 Zstrategyr r r Úrewrite;s)zRuleSet.rewriteN)rT) rr r!r"rrFrRrSrVr r r r rCÊs '  rCcCs | |¡S)N)rS)Únetrr r r Ú _top_levelgsrXcsXt|ƒr.t|ƒft‡fdd„t|ƒDƒƒ}n t|tƒrN‡fdd„t|ƒDƒ}ˆ |¡S)Nc3s|]}tˆ|ƒVqdS)N)Ú _bottom_up)r1r2)rWr r ú msz_bottom_up..csg|]}tˆ|ƒ‘qSr )rY)r1r2)rWr r r4osz_bottom_up..)rr r*rrr rS)rWrr )rWr rYks & rY)Z top_levelrTccsÞtƒ}d}d}xÊ|jtkr&|j|fVy>|j |jd¡}|rb|sb| | ¡||f¡|}| ¡wWnt k rxYnX|j t d¡}|rªd}||j f}|  ¡|}qy|  ¡\}}}d}Wqtk rÔdSXqWdS)z;Structural matching of term S to discrimination net node N.Fr NT)rrrr.r-ÚgetrJrrr5rIrrrÚ Exception)rNÚNrZrestore_state_flagZmatchesÚnr r r rLws6   rLcCs^i}|j}t|ƒt|ƒks"tdƒ‚x6t||ƒD](\}}||krN|||krNdS|||<q.W|S)aÉProcess 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)r:rHÚ RuntimeErrorÚzip)rKrPrZvarlistÚvÚsr r r rMs rMN)Z __future__rrrÚ collectionsrZ dask.corerrr rÚobjectrr$rIrr*r)r0rCrXrYrUrLrMr r r r Ús$   < H&