ó ¦–Õ\c@`sddlmZmZmZddlmZddlmZmZd„Z d„Z de fd„ƒYZ de fd „ƒYZ e d ƒZe d ƒZd efd „ƒYZde fd„ƒYZde fd„ƒYZd„Zd„Zied6ed6Zd„Zd„ZdS(i(tabsolute_importtdivisiontprint_function(tdeque(tistasktsubscC`s/t|ƒr|dSt|tƒr'tS|SdS(s#Return the top level node of a taskiN(Rt isinstancetlist(ttask((s+lib/python2.7/site-packages/dask/rewrite.pytheads  cC`s/t|ƒr|dSt|tƒr'|SdSdS(s&Get the arguments for the current taskiN((RRR(R((s+lib/python2.7/site-packages/dask/rewrite.pytargss  t TraversercB`sMeZdZdd„Zd„Zd„Zd„Zed„ƒZ d„Z RS(s£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`. cC`s1||_|s$ttgƒ|_n ||_dS(N(ttermRtENDt_stack(tselfR tstack((s+lib/python2.7/site-packages/dask/rewrite.pyt__init__2s cc`s,x%|jtk r'|jV|jƒqWdS(N(tcurrentR tnext(R((s+lib/python2.7/site-packages/dask/rewrite.pyt__iter__9scC`st|jt|jƒƒS(s…Copy the traverser in its current state. This allows the traversal to be pushed onto a stack, for easy backtracking.(R R RR(R((s+lib/python2.7/site-packages/dask/rewrite.pytcopy>scC`sUt|jƒ}|s*|jjƒ|_n'|d|_|jjt|dƒƒdS(s3Proceed to the next term in the preorder traversal.iiN(R R Rtpoptextendtreversed(Rtsubterms((s+lib/python2.7/site-packages/dask/rewrite.pyRFs  cC`s t|jƒS(N(R R (R((s+lib/python2.7/site-packages/dask/rewrite.pyRQscC`s|jjƒ|_dS(s<Skip over all subterms of the current level in the traversalN(RRR (R((s+lib/python2.7/site-packages/dask/rewrite.pytskipUsN( t__name__t __module__t__doc__tNoneRRRRtpropertyRR(((s+lib/python2.7/site-packages/dask/rewrite.pyR s    tTokencB`s eZdZd„Zd„ZRS(s[A token object. Used to express certain objects in the traversal of a task or pattern.cC`s ||_dS(N(tname(RR!((s+lib/python2.7/site-packages/dask/rewrite.pyR_scC`s|jS(N(R!(R((s+lib/python2.7/site-packages/dask/rewrite.pyt__repr__bs(RRRRR"(((s+lib/python2.7/site-packages/dask/rewrite.pyR Zs t?tendtNodecB`sAeZdZdZddd„Zed„ƒZed„ƒZRS(sA Discrimination Net node.cC`s:|r |ni}|r|ng}tj|||fƒS(N(ttuplet__new__(tclstedgestpatterns((s+lib/python2.7/site-packages/dask/rewrite.pyR'rscC`s|dS(s@A dictionary, where the keys are edges, and the values are nodesi((R((s+lib/python2.7/site-packages/dask/rewrite.pyR)wscC`s|dS(s8A list of all patterns that currently match at this nodei((R((s+lib/python2.7/site-packages/dask/rewrite.pyR*|s(N( RRRt __slots__RR'RR)R*(((s+lib/python2.7/site-packages/dask/rewrite.pyR%ms t RewriteRulecB`s5eZdZdd„Zd„Zd„Zd„ZRS(så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. >>> 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) cC`s¤t|tƒstdƒ‚n||_t|ƒr?||_n |j|_||_gt|ƒD]}||kra|^qa|_ tt t |j ƒƒƒ|_ dS(Ns!vars must be a tuple of variables( RR&t TypeErrortlhstcallableRt_applytrhsR t_varlisttsortedtsettvars(RR.R1R5tt((s+lib/python2.7/site-packages/dask/rewrite.pyR¯s     .cC`s<|j}x,|jƒD]\}}t|||ƒ}qW|S(N(R1titemsR(Rtsub_dictR tkeytval((s+lib/python2.7/site-packages/dask/rewrite.pyR0¼s cC`sdj|j|j|jƒS(NsRewriteRule({0}, {1}, {2})(tformatR.R1R5(R((s+lib/python2.7/site-packages/dask/rewrite.pyt__str__ÂscC`s t|ƒS(N(tstr(R((s+lib/python2.7/site-packages/dask/rewrite.pyR"Æs((RRRRR0R<R"(((s+lib/python2.7/site-packages/dask/rewrite.pyR,‚s +  tRuleSetcB`s>eZdZd„Zd„Zd„Zd„Zdd„ZRS(s?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`. cG`s7tƒ|_g|_x|D]}|j|ƒqWdS(s—Create a `RuleSet` for a number of rules Parameters ---------- rules One or more instances of RewriteRule N(R%t_nettrulestadd(RR@tp((s+lib/python2.7/site-packages/dask/rewrite.pyRós   cC`sÛt|tƒstdƒ‚n|j}|j}t|jƒ}xnt|jƒD]]}|}||krpt }n||j kr|j |}qOt ƒ|j |<|j |}qOW|j |j j |ƒ|jj |ƒdS(seAdd a rule to the RuleSet. Parameters ---------- rule : RewriteRule s$rule must be instance of RewriteRuleN(RR,R-R5R?tlenR@R R.tVARR)R%R*tappend(RtruleR5t curr_nodetindR6t prev_node((s+lib/python2.7/site-packages/dask/rewrite.pyRAs    cc`szt|ƒ}xgt||jƒD]S\}}xD|D]<}|j|}t||ƒ}|dk r2||fVq2q2WqWdS(slA 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 t_matchR?R@t_process_matchR(RR tStmtsymstiRFR((s+lib/python2.7/site-packages/dask/rewrite.pyt iter_matchess    cC`s4x-|j|ƒD]\}}|j|ƒ}PqW|S(s7Apply the rewrite rules in RuleSet to top level of term(RPR(RR RFtsd((s+lib/python2.7/site-packages/dask/rewrite.pyt_rewrite0st bottom_upcC`st|||ƒS(seApply 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)) (t strategies(RRtstrategy((s+lib/python2.7/site-packages/dask/rewrite.pytrewrite;s)(RRRRRARPRRRV(((s+lib/python2.7/site-packages/dask/rewrite.pyR>Ês '   cC`s |j|ƒS(N(RR(tnetR ((s+lib/python2.7/site-packages/dask/rewrite.pyt _top_levelgsc`s…t|ƒr>t|ƒft‡fd†t|ƒDƒƒ}n:t|tƒrxgt|ƒD]}tˆ|ƒ^qZ}nˆj|ƒS(Nc3`s|]}tˆ|ƒVqdS(N(t _bottom_up(t.0R6(RW(s+lib/python2.7/site-packages/dask/rewrite.pys ms(RR R&R RRRYRR(RWR R6((RWs+lib/python2.7/site-packages/dask/rewrite.pyRYks  2+t top_levelRScc`s0tƒ}t}d}xtr+|jtkr>|j|fVny[|jj|jdƒ}|r˜| r˜|j |j ƒ||fƒ|}|j ƒwnWnt k r¬nX|jjt dƒ}|rôt}||jf}|jƒ|}qny|jƒ\}}}t}Wqtk r'dSXqWdS(s;Structural matching of term S to discrimination net node N.N((RtFalsetTrueRR R*R)tgetRRERRR-RDR RRt Exception(RLtNRtrestore_state_flagtmatchestn((s+lib/python2.7/site-packages/dask/rewrite.pyRJws6         cC`s„i}|j}t|ƒt|ƒks6tdƒ‚nxGt||ƒD]6\}}||krr|||krrdS|||RXRYRTRJRK(((s+lib/python2.7/site-packages/dask/rewrite.pyts" <  H     &