py2dag 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

py2dag/parser.py

@@ -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:
@@ -245,6 +288,26 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
             })
             return ssa
 
+        def _emit_assign_from_subscript(var_name: str, node: ast.Subscript) -> str:
+            # Support name[key] where key is a JSON-serialisable literal
+            base = node.value
+            if not isinstance(base, ast.Name):
+                raise DSLParseError("Subscript base must be a variable name")
+            # Extract slice expression across Python versions
+            sl = getattr(node, 'slice', None)
+            # In Python >=3.9, slice is the actual node; before it may be ast.Index
+            if hasattr(ast, 'Index') and isinstance(sl, getattr(ast, 'Index')):  # type: ignore[attr-defined]
+                sl = sl.value  # type: ignore[assignment]
+            key = _literal(sl)  # may raise if not literal
+            ssa = _ssa_new(var_name)
+            ops.append({
+                "id": ssa,
+                "op": "GET.item",
+                "deps": [_ssa_get(base.id)],
+                "args": {"key": key},
+            })
+            return ssa
+
         def _emit_cond(node: ast.AST, kind: str = "if") -> str:
             expr = _stringify(node)
             deps = [_ssa_get(n) for n in _collect_value_deps(node)]
@@ -279,6 +342,8 @@ def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
                     return _emit_assign_from_literal_or_pack(var_name, value)
                 elif isinstance(value, (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)):
                     return _emit_assign_from_comp(var_name, value)
+                elif isinstance(value, ast.Subscript):
+                    return _emit_assign_from_subscript(var_name, value)
                 else:
                     raise DSLParseError("Right hand side must be a call or f-string")
             elif isinstance(stmt, ast.Expr):
@@ -310,7 +375,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):
@@ -411,6 +477,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
@@ -419,6 +508,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]
@@ -461,7 +560,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.2.dist-info → py2dag-0.2.4.dist-info}/METADATA

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

{py2dag-0.2.2.dist-info → py2dag-0.2.4.dist-info}/RECORD

@@ -2,10 +2,10 @@ py2dag/__init__.py,sha256=i8VB44JCVcRJAcvnQtbH8YVRUz5j7dE355iRbikXPGQ,250
 py2dag/cli.py,sha256=BCBi5mNxOqeEN8uEMt_hiDx0iSt7ZE3y74cGXREzZ2I,1296
 py2dag/export_dagre.py,sha256=lScDQCIh5nE3RI_ac4Ye8AsLnn3MIn-fm1WlqP9Ei4U,4608
 py2dag/export_svg.py,sha256=tKqh16hCrCE1QJ9-MTue1ELRxmXOb2akokpSz_a5eE8,2383
-py2dag/parser.py,sha256=XTs1ItzAmXkAvpJX1BfyUlI25kMJp-GVqbYnpU9wdP4,23675
+py2dag/parser.py,sha256=mJX_rjjSnO7G0-3thh5bBpPlG8N0IWAUqnp4Yn7Vd3A,28711
 py2dag/pseudo.py,sha256=NJK61slyFLtSjhj8gJDJneUInEpBN57_41g8IfHNPWI,922
-py2dag-0.2.2.dist-info/LICENSE,sha256=3Qee1EPwej_nusovTbyIQ8LvD2rXHdM0c6LNwk_D8Kc,1067
-py2dag-0.2.2.dist-info/METADATA,sha256=0HlPv8M1BBtNm0o-W1qJv7kI0S7J-UYOnTCrCGXnjSc,3549
-py2dag-0.2.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-py2dag-0.2.2.dist-info/entry_points.txt,sha256=Q0SHexJJ0z1te4AYL1xTZogx5FrxCCE1ZJ5qntkFMZs,42
-py2dag-0.2.2.dist-info/RECORD,,
+py2dag-0.2.4.dist-info/LICENSE,sha256=3Qee1EPwej_nusovTbyIQ8LvD2rXHdM0c6LNwk_D8Kc,1067
+py2dag-0.2.4.dist-info/METADATA,sha256=yNQ2eR_WmySOQGRyq0uzvuYeKzV5_AxH2FTlSfPIvd0,3549
+py2dag-0.2.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+py2dag-0.2.4.dist-info/entry_points.txt,sha256=Q0SHexJJ0z1te4AYL1xTZogx5FrxCCE1ZJ5qntkFMZs,42
+py2dag-0.2.4.dist-info/RECORD,,