PyPI - py2dag - Versions diffs - 0.2.1__tar.gz → 0.2.3__tar.gz - Mend

py2dag 0.2.1tar.gz → 0.2.3tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

{py2dag-0.2.1 → py2dag-0.2.3}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py2dag
-Version: 0.2.1
+Version: 0.2.3
 Summary: Convert Python function plans to DAG (JSON, pseudo, optional SVG).
 License: MIT
 Author: rvergis

{py2dag-0.2.1 → py2dag-0.2.3}/py2dag/export_dagre.py RENAMED Viewed

@@ -73,10 +73,21 @@ HTML_TEMPLATE = """<!doctype html>
           g.setEdge(out.from, outId);
         });
-        // Add dependency edges between ops
+        // Build index for source op lookup
+        const opById = {};
+        (plan.ops || []).forEach(op => { opById[op.id] = op; });
+        // Add dependency edges between ops with labels
         (plan.ops || []).forEach(op => {
           (op.deps || []).forEach(dep => {
-            g.setEdge(dep, op.id);
+            const src = opById[dep];
+            let edgeLabel = dep; // default to SSA id
+            if (src && src.op === 'COND.eval') {
+              edgeLabel = 'cond';
+            } else if (src && src.op === 'ITER.eval') {
+              edgeLabel = (src.args && src.args.target) ? src.args.target : 'iter';
+            }
+            g.setEdge(dep, op.id, { label: edgeLabel });
           });
         });

{py2dag-0.2.1 → py2dag-0.2.3}/py2dag/export_svg.py RENAMED Viewed

@@ -22,10 +22,27 @@ def export(plan: Dict[str, Any], filename: str = "plan.svg") -> str:
         raise RuntimeError("Python package 'graphviz' is required for SVG export")
     graph = Digraph(format="svg")
-    for op in plan.get("ops", []):
+    # Index ops for edge label decisions
+    ops = list(plan.get("ops", []))
+    op_by_id = {op["id"]: op for op in ops}
+    # Nodes
+    for op in ops:
         graph.node(op["id"], label=op["op"])
+    # Dependency edges with labels showing data/control
+    for op in ops:
         for dep in op.get("deps", []):
-            graph.edge(dep, op["id"])
+            src = op_by_id.get(dep)
+            label = dep  # default to SSA id
+            if src is not None:
+                if src.get("op") == "COND.eval":
+                    label = "cond"
+                elif src.get("op") == "ITER.eval":
+                    args = src.get("args", {}) or {}
+                    label = str(args.get("target") or "iter")
+            graph.edge(dep, op["id"], label=label)
     for out in plan.get("outputs", []):
         out_id = f"out:{out['as']}"
         graph.node(out_id, label=out['as'], shape="note")

{py2dag-0.2.1 → py2dag-0.2.3}/py2dag/parser.py RENAMED Viewed

@@ -173,6 +173,10 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
             ops.append({"id": ssa, "op": op_name, "deps": deps, "args": kwargs})
             return ssa
+        def _emit_expr_call(call: ast.Call) -> str:
+            """Emit a node for a bare expression call (no assignment)."""
+            return _emit_assign_from_call("call", call)
         def _emit_assign_from_fstring(var_name: str, fstr: ast.JoinedStr) -> str:
             deps: List[str] = []
             parts: List[str] = []
@@ -222,6 +226,45 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
                         "args": {},
                     })
                     return ssa
+                if isinstance(value, ast.Dict):
+                    # Support dict with values from names/calls or literals by synthesizing nodes
+                    keys: List[str] = []
+                    deps: List[str] = []
+                    for k_node, v_node in zip(value.keys, value.values):
+                        k_str = _literal(k_node)
+                        if not isinstance(k_str, (str, int, float, bool)):
+                            k_str = str(k_str)
+                        keys.append(str(k_str))
+                        if isinstance(v_node, ast.Name):
+                            deps.append(_ssa_get(v_node.id))
+                        elif isinstance(v_node, ast.Await):
+                            inner = v_node.value
+                            if not isinstance(inner, ast.Call):
+                                raise DSLParseError("await must wrap a call in dict value")
+                            tmp_id = _emit_assign_from_call(f"{var_name}_field", inner)
+                            deps.append(tmp_id)
+                        elif isinstance(v_node, ast.Call):
+                            tmp_id = _emit_assign_from_call(f"{var_name}_field", v_node)
+                            deps.append(tmp_id)
+                        else:
+                            # Synthesize const for literal value
+                            lit_val = _literal(v_node)
+                            tmp = _ssa_new(f"{var_name}_lit")
+                            ops.append({
+                                "id": tmp,
+                                "op": "CONST.value",
+                                "deps": [],
+                                "args": {"value": lit_val},
+                            })
+                            deps.append(tmp)
+                    ssa = _ssa_new(var_name)
+                    ops.append({
+                        "id": ssa,
+                        "op": "PACK.dict",
+                        "deps": deps,
+                        "args": {"keys": keys},
+                    })
+                    return ssa
                 raise
         def _emit_assign_from_comp(var_name: str, node: ast.AST) -> str:
@@ -252,11 +295,14 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
             ops.append({"id": ssa, "op": "COND.eval", "deps": deps, "args": {"expr": expr, "kind": kind}})
             return ssa
-        def _emit_iter(node: ast.AST) -> str:
+        def _emit_iter(node: ast.AST, target_label: Optional[str] = None) -> str:
             expr = _stringify(node)
             deps = [_ssa_get(n) for n in _collect_value_deps(node)]
             ssa = _ssa_new("iter")
-            ops.append({"id": ssa, "op": "ITER.eval", "deps": deps, "args": {"expr": expr, "kind": "for"}})
+            args = {"expr": expr, "kind": "for"}
+            if target_label:
+                args["target"] = target_label
+            ops.append({"id": ssa, "op": "ITER.eval", "deps": deps, "args": args})
             return ssa
         def _parse_stmt(stmt: ast.stmt) -> Optional[str]:
@@ -307,7 +353,8 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
                         raise DSLParseError("output requires as=\"filename\"")
                     outputs.append({"from": ssa_from, "as": filename})
                 else:
-                    raise DSLParseError("Only settings() and output() calls allowed as expressions")
+                    # General expression call: represent as an op node too
+                    _emit_expr_call(call)
                 return None
             elif isinstance(stmt, ast.Return):
                 if isinstance(stmt.value, ast.Name):
@@ -383,7 +430,19 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
                 return None
             elif isinstance(stmt, (ast.For, ast.AsyncFor)):
                 # ITER over iterable
-                iter_id = _emit_iter(stmt.iter)
+                # Determine loop target label if simple
+                t = stmt.target
+                t_label: Optional[str] = None
+                if isinstance(t, ast.Name):
+                    t_label = t.id
+                elif isinstance(t, ast.Tuple) and all(isinstance(e, ast.Name) for e in t.elts):
+                    t_label = ",".join(e.id for e in t.elts)  # type: ignore[attr-defined]
+                else:
+                    try:
+                        t_label = ast.unparse(t)  # type: ignore[attr-defined]
+                    except Exception:
+                        t_label = None
+                iter_id = _emit_iter(stmt.iter, target_label=t_label)
                 # Save pre-loop state
                 pre_versions = dict(versions)
                 pre_latest = dict(latest)
@@ -396,6 +455,29 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
                 ctx_counts["loop"] += 1
                 context_suffix = f"loop{ctx_counts['loop']}"
                 versions, latest = versions_body, latest_body
+                # Predefine loop target variables as items from iterator for dependency resolution
+                def _bind_loop_target(target: ast.AST):
+                    if isinstance(target, ast.Name):
+                        ssa_item = _ssa_new(target.id)
+                        ops.append({
+                            "id": ssa_item,
+                            "op": "ITER.item",
+                            "deps": [iter_id],
+                            "args": {"target": target.id},
+                        })
+                    elif isinstance(target, ast.Tuple):
+                        for elt in target.elts:
+                            if isinstance(elt, ast.Name):
+                                ssa_item = _ssa_new(elt.id)
+                                ops.append({
+                                    "id": ssa_item,
+                                    "op": "ITER.item",
+                                    "deps": [iter_id],
+                                    "args": {"target": elt.id},
+                                })
+                    # Other patterns are ignored for now
+                _bind_loop_target(stmt.target)
                 for inner in stmt.body:
                     _parse_stmt(inner)
                 versions_body, latest_body = versions, latest
@@ -404,6 +486,16 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
                 # Add iter dep to first op in body
                 if len(ops) > body_ops_start:
                     ops[body_ops_start]["deps"] = [*ops[body_ops_start].get("deps", []), iter_id]
+                # Emit a summary foreach comp node depending on iterable value deps
+                iter_name_deps = _collect_value_deps(stmt.iter)
+                foreach_deps = [_ssa_get(n) for n in iter_name_deps]
+                ssa_foreach = _ssa_new("foreach")
+                ops.append({
+                    "id": ssa_foreach,
+                    "op": "COMP.foreach",
+                    "deps": foreach_deps,
+                    "args": {"target": t_label or ""},
+                })
                 # Loop-carried vars: only those existing pre-loop and reassigned in body
                 changed = {k for k in latest_body if pre_latest.get(k) != latest_body.get(k)}
                 carried = [k for k in changed if k in pre_latest]
@@ -446,7 +538,7 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
                         "args": {"var": var},
                     })
                 return None
-            elif isinstance(stmt, (ast.Pass,)):
+            elif isinstance(stmt, (ast.Pass, ast.Continue, ast.Break)):
                 return None
             else:
                 raise DSLParseError("Only assignments, control flow, settings/output calls, and return are allowed in function body")

{py2dag-0.2.1 → py2dag-0.2.3}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry]
 name = "py2dag"
-version = "0.2.1"
+version = "0.2.3"
 description = "Convert Python function plans to DAG (JSON, pseudo, optional SVG)."
 authors = ["rvergis"]
 license = "MIT"

{py2dag-0.2.1 → py2dag-0.2.3}/LICENSE RENAMED Viewed

File without changes

{py2dag-0.2.1 → py2dag-0.2.3}/README.md RENAMED Viewed

File without changes

{py2dag-0.2.1 → py2dag-0.2.3}/py2dag/__init__.py RENAMED Viewed

File without changes

{py2dag-0.2.1 → py2dag-0.2.3}/py2dag/cli.py RENAMED Viewed

File without changes

{py2dag-0.2.1 → py2dag-0.2.3}/py2dag/pseudo.py RENAMED Viewed

File without changes

py2dag 0.2.1__tar.gz → 0.2.3__tar.gz

py2dag 0.2.1tar.gz → 0.2.3tar.gz