py2dag 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

py2dag/cli.py

@@ -9,7 +9,7 @@ from . import export_svg
 def main() -> None:
     ap = argparse.ArgumentParser(description="Convert Python function plan to DAG")
     ap.add_argument("file", help="Python file containing the plan function")
-    ap.add_argument("--func", default="plan", help="Function name to parse")
+    ap.add_argument("--func", default=None, help="Function name to parse (auto-detect if omitted)")
     ap.add_argument("--svg", action="store_true", help="Also export plan.svg via Graphviz (requires dot)")
     ap.add_argument("--html", action="store_true", help="Also export plan.html via Dagre (no system deps)")
     args = ap.parse_args()

py2dag/parser.py

@@ -35,139 +35,158 @@ def _get_call_name(func: ast.AST) -> str:
     raise DSLParseError("Only simple or attribute names are allowed for operations")
 
 
-def parse(source: str, function_name: str = "plan") -> Dict[str, Any]:
+def parse(source: str, function_name: Optional[str] = None) -> Dict[str, Any]:
     if len(source) > 20_000:
         raise DSLParseError("Source too large")
     module = ast.parse(source)
-    fn = None
-    for node in module.body:
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == function_name:
-            fn = node
-            break
-    if fn is None:
-        raise DSLParseError(f"Function {function_name!r} not found")
-
-    defined: set[str] = set()
-    ops: List[Dict[str, Any]] = []
-    outputs: List[Dict[str, str]] = []
-    settings: Dict[str, Any] = {}
-
-    returned_var: Optional[str] = None
-    for i, stmt in enumerate(fn.body):
-        if isinstance(stmt, ast.Assign):
-            if len(stmt.targets) != 1 or not isinstance(stmt.targets[0], ast.Name):
-                raise DSLParseError("Assignment targets must be simple names")
-            var_name = stmt.targets[0].id
-            if not VALID_NAME_RE.match(var_name):
-                raise DSLParseError(f"Invalid variable name: {var_name}")
-            if var_name in defined:
-                raise DSLParseError(f"Duplicate variable name: {var_name}")
-
-            value = stmt.value
-            if isinstance(value, ast.Await):
-                value = value.value
-            if isinstance(value, ast.Call):
-                op_name = _get_call_name(value.func)
-
-                deps: List[str] = []
-                for arg in value.args:
-                    if not isinstance(arg, ast.Name):
-                        raise DSLParseError("Positional args must be variable names")
-                    if arg.id not in defined:
-                        raise DSLParseError(f"Undefined dependency: {arg.id}")
-                    deps.append(arg.id)
-
-                kwargs: Dict[str, Any] = {}
-                for kw in value.keywords:
-                    if kw.arg is None:
-                        raise DSLParseError("**kwargs are not allowed")
-                    kwargs[kw.arg] = _literal(kw.value)
-
-                ops.append({"id": var_name, "op": op_name, "deps": deps, "args": kwargs})
-            elif isinstance(value, ast.JoinedStr):
-                # Minimal f-string support: only variable placeholders
-                deps: List[str] = []
-                parts: List[str] = []
-                for item in value.values:
-                    if isinstance(item, ast.Constant) and isinstance(item.value, str):
-                        parts.append(item.value)
-                    elif isinstance(item, ast.FormattedValue) and isinstance(item.value, ast.Name):
-                        name = item.value.id
-                        if name not in defined:
-                            raise DSLParseError(f"Undefined dependency: {name}")
-                        deps.append(name)
-                        parts.append("{" + str(len(deps) - 1) + "}")
-                    else:
-                        raise DSLParseError("f-strings may only contain variable names")
-                template = "".join(parts)
-                ops.append({
-                    "id": var_name,
-                    "op": "TEXT.format",
-                    "deps": deps,
-                    "args": {"template": template},
-                })
-            else:
-                raise DSLParseError("Right hand side must be a call or f-string")
-            defined.add(var_name)
-
-        elif isinstance(stmt, ast.Expr):
-            call = stmt.value
-            if isinstance(call, ast.Await):
-                call = call.value
-            if not isinstance(call, ast.Call):
-                raise DSLParseError("Only call expressions allowed at top level")
-            name = _get_call_name(call.func)
-            if name == "settings":
-                for kw in call.keywords:
-                    if kw.arg is None:
-                        raise DSLParseError("settings does not accept **kwargs")
-                    settings[kw.arg] = _literal(kw.value)
-                if call.args:
-                    raise DSLParseError("settings only accepts keyword literals")
-            elif name == "output":
-                if len(call.args) != 1 or not isinstance(call.args[0], ast.Name):
-                    raise DSLParseError("output requires a single variable name argument")
-                var = call.args[0].id
+
+    def _parse_fn(fn: ast.AST) -> Dict[str, Any]:
+        defined: set[str] = set()
+        ops: List[Dict[str, Any]] = []
+        outputs: List[Dict[str, str]] = []
+        settings: Dict[str, Any] = {}
+
+        returned_var: Optional[str] = None
+        # type: ignore[attr-defined]
+        for i, stmt in enumerate(fn.body):  # type: ignore[attr-defined]
+            if isinstance(stmt, ast.Assign):
+                if len(stmt.targets) != 1 or not isinstance(stmt.targets[0], ast.Name):
+                    raise DSLParseError("Assignment targets must be simple names")
+                var_name = stmt.targets[0].id
+                if not VALID_NAME_RE.match(var_name):
+                    raise DSLParseError(f"Invalid variable name: {var_name}")
+                if var_name in defined:
+                    raise DSLParseError(f"Duplicate variable name: {var_name}")
+
+                value = stmt.value
+                if isinstance(value, ast.Await):
+                    value = value.value
+                if isinstance(value, ast.Call):
+                    op_name = _get_call_name(value.func)
+
+                    deps: List[str] = []
+                    for arg in value.args:
+                        if not isinstance(arg, ast.Name):
+                            raise DSLParseError("Positional args must be variable names")
+                        if arg.id not in defined:
+                            raise DSLParseError(f"Undefined dependency: {arg.id}")
+                        deps.append(arg.id)
+
+                    kwargs: Dict[str, Any] = {}
+                    for kw in value.keywords:
+                        if kw.arg is None:
+                            raise DSLParseError("**kwargs are not allowed")
+                        kwargs[kw.arg] = _literal(kw.value)
+
+                    ops.append({"id": var_name, "op": op_name, "deps": deps, "args": kwargs})
+                elif isinstance(value, ast.JoinedStr):
+                    # Minimal f-string support: only variable placeholders
+                    deps: List[str] = []
+                    parts: List[str] = []
+                    for item in value.values:
+                        if isinstance(item, ast.Constant) and isinstance(item.value, str):
+                            parts.append(item.value)
+                        elif isinstance(item, ast.FormattedValue) and isinstance(item.value, ast.Name):
+                            name = item.value.id
+                            if name not in defined:
+                                raise DSLParseError(f"Undefined dependency: {name}")
+                            deps.append(name)
+                            parts.append("{" + str(len(deps) - 1) + "}")
+                        else:
+                            raise DSLParseError("f-strings may only contain variable names")
+                    template = "".join(parts)
+                    ops.append({
+                        "id": var_name,
+                        "op": "TEXT.format",
+                        "deps": deps,
+                        "args": {"template": template},
+                    })
+                else:
+                    raise DSLParseError("Right hand side must be a call or f-string")
+                defined.add(var_name)
+
+            elif isinstance(stmt, ast.Expr):
+                call = stmt.value
+                if isinstance(call, ast.Await):
+                    call = call.value
+                if not isinstance(call, ast.Call):
+                    raise DSLParseError("Only call expressions allowed at top level")
+                name = _get_call_name(call.func)
+                if name == "settings":
+                    for kw in call.keywords:
+                        if kw.arg is None:
+                            raise DSLParseError("settings does not accept **kwargs")
+                        settings[kw.arg] = _literal(kw.value)
+                    if call.args:
+                        raise DSLParseError("settings only accepts keyword literals")
+                elif name == "output":
+                    if len(call.args) != 1 or not isinstance(call.args[0], ast.Name):
+                        raise DSLParseError("output requires a single variable name argument")
+                    var = call.args[0].id
+                    if var not in defined:
+                        raise DSLParseError(f"Undefined output variable: {var}")
+                    filename = None
+                    for kw in call.keywords:
+                        if kw.arg in {"as", "as_"}:
+                            filename = _literal(kw.value)
+                        else:
+                            raise DSLParseError("output only accepts 'as' keyword")
+                    if filename is None or not isinstance(filename, str):
+                        raise DSLParseError("output requires as=\"filename\"")
+                    outputs.append({"from": var, "as": filename})
+                else:
+                    raise DSLParseError("Only settings() and output() calls allowed as expressions")
+            elif isinstance(stmt, ast.Return):
+                if i != len(fn.body) - 1:  # type: ignore[index]
+                    raise DSLParseError("return must be the last statement")
+                if not isinstance(stmt.value, ast.Name):
+                    raise DSLParseError("return must return a variable name")
+                var = stmt.value.id
                 if var not in defined:
-                    raise DSLParseError(f"Undefined output variable: {var}")
-                filename = None
-                for kw in call.keywords:
-                    if kw.arg in {"as", "as_"}:
-                        filename = _literal(kw.value)
-                    else:
-                        raise DSLParseError("output only accepts 'as' keyword")
-                if filename is None or not isinstance(filename, str):
-                    raise DSLParseError("output requires as=\"filename\"")
-                outputs.append({"from": var, "as": filename})
+                    raise DSLParseError(f"Undefined return variable: {var}")
+                returned_var = var
+            else:
+                raise DSLParseError("Only assignments, expression calls, and a final return are allowed in function body")
+
+        if not outputs:
+            if returned_var is not None:
+                outputs.append({"from": returned_var, "as": "return"})
             else:
-                raise DSLParseError("Only settings() and output() calls allowed as expressions")
-        elif isinstance(stmt, ast.Return):
-            if i != len(fn.body) - 1:
-                raise DSLParseError("return must be the last statement")
-            if not isinstance(stmt.value, ast.Name):
-                raise DSLParseError("return must return a variable name")
-            var = stmt.value.id
-            if var not in defined:
-                raise DSLParseError(f"Undefined return variable: {var}")
-            returned_var = var
-        else:
-            raise DSLParseError("Only assignments, expression calls, and a final return are allowed in function body")
-
-    if not outputs:
-        if returned_var is not None:
-            outputs.append({"from": returned_var, "as": "return"})
-        else:
-            raise DSLParseError("At least one output() call required")
-    if len(ops) > 200:
-        raise DSLParseError("Too many operations")
-
-    plan: Dict[str, Any] = {"version": 1, "ops": ops, "outputs": outputs}
-    if settings:
-        plan["settings"] = settings
-    return plan
-
-
-def parse_file(filename: str, function_name: str = "plan") -> Dict[str, Any]:
+                raise DSLParseError("At least one output() call required")
+        if len(ops) > 200:
+            raise DSLParseError("Too many operations")
+
+        plan: Dict[str, Any] = {"version": 1, "ops": ops, "outputs": outputs}
+        if settings:
+            plan["settings"] = settings
+        return plan
+
+    # If a specific function name is provided, use it; otherwise try to auto-detect
+    if function_name is not None:
+        fn: Optional[ast.AST] = None
+        for node in module.body:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name == function_name:
+                fn = node
+                break
+        if fn is None:
+            raise DSLParseError(f"Function {function_name!r} not found")
+        return _parse_fn(fn)
+    else:
+        last_err: Optional[Exception] = None
+        for node in module.body:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                try:
+                    return _parse_fn(node)
+                except DSLParseError as e:
+                    last_err = e
+                    continue
+        # If we got here, either there are no functions or none matched the DSL
+        if last_err is not None:
+            raise DSLParseError("No suitable function matched the DSL; specify --func to disambiguate") from last_err
+        raise DSLParseError("No function definitions found in source")
+
+
+def parse_file(filename: str, function_name: Optional[str] = None) -> Dict[str, Any]:
     with open(filename, "r", encoding="utf-8") as f:
         src = f.read()
     return parse(src, function_name=function_name)

{py2dag-0.1.4.dist-info → py2dag-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: py2dag
-Version: 0.1.4
+Version: 0.1.5
 Summary: Convert Python function plans to DAG (JSON, pseudo, optional SVG).
 License: MIT
 Author: rvergis
@@ -76,6 +76,8 @@ poetry run python cli.py path/to/your_file.py --html
 
 This generates `plan.json`, `plan.pseudo`, and if `--html` is used, `plan.html`.
 
+- Function name: By default the tool auto-detects a suitable function in the file. To target a specific function, pass `--func NAME`.
+
 ### Offline HTML (no internet)
 
 `plan.html` references d3 and dagre-d3 from CDNs. To view graphs fully offline, download those files and place them next to `plan.html`, then edit the two `<script>` tags in `py2dag/export_dagre.py` to point at your local copies.
@@ -111,18 +113,17 @@ This repo includes a GitHub Actions workflow that publishes to PyPI when you pus
 
 1) In GitHub repo settings, add a repository secret named `PYPI_API_TOKEN` with your PyPI token (format: `pypi-***`).
 
-2) Bump patch version, create tag, and push it (this triggers the workflow):
+2) Bump patch version, commit, and tag locally; then push tags to trigger the workflow:
 
 ```
-make release
+make patch        # bumps version, commits, and tags vX.Y.Z
+make release      # pushes tags to GitHub (triggers publish)
 ```
 
-Or do individual steps:
+Or push tags manually:
 
 ```
-make bump-patch
-make tag
-make push-tags
+git push --tags
 ```
 
 You can also install from the local build with `pip install dist/*.whl`.

py2dag-0.1.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+py2dag/__init__.py,sha256=i8VB44JCVcRJAcvnQtbH8YVRUz5j7dE355iRbikXPGQ,250
+py2dag/cli.py,sha256=BCBi5mNxOqeEN8uEMt_hiDx0iSt7ZE3y74cGXREzZ2I,1296
+py2dag/export_dagre.py,sha256=S244wUxBMuM9qXD8bklaslkMp3rcbBGWvMhwWVBzBF0,3487
+py2dag/export_svg.py,sha256=YyjqOuj8GhUTDWP70SKnnSWAKI1PvJwyOhHLwB29uNM,1812
+py2dag/parser.py,sha256=2sYscG3hFHK7RxJ6rNlO1w9GnxF-9hZG6SMAs_oGDu0,8849
+py2dag/pseudo.py,sha256=NJK61slyFLtSjhj8gJDJneUInEpBN57_41g8IfHNPWI,922
+py2dag-0.1.5.dist-info/LICENSE,sha256=3Qee1EPwej_nusovTbyIQ8LvD2rXHdM0c6LNwk_D8Kc,1067
+py2dag-0.1.5.dist-info/METADATA,sha256=yEDK8WOlw2SYEa5J_3H7OINAfFLmPLgvi0UzJ50O9Cg,3537
+py2dag-0.1.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+py2dag-0.1.5.dist-info/entry_points.txt,sha256=Q0SHexJJ0z1te4AYL1xTZogx5FrxCCE1ZJ5qntkFMZs,42
+py2dag-0.1.5.dist-info/RECORD,,

py2dag-0.1.4.dist-info/RECORD

@@ -1,11 +0,0 @@
-py2dag/__init__.py,sha256=i8VB44JCVcRJAcvnQtbH8YVRUz5j7dE355iRbikXPGQ,250
-py2dag/cli.py,sha256=zedwk2_bnm4BlzrPxwYP3NNaofySxEz_ydUk6e7sE_E,1273
-py2dag/export_dagre.py,sha256=S244wUxBMuM9qXD8bklaslkMp3rcbBGWvMhwWVBzBF0,3487
-py2dag/export_svg.py,sha256=YyjqOuj8GhUTDWP70SKnnSWAKI1PvJwyOhHLwB29uNM,1812
-py2dag/parser.py,sha256=aWchBHISd5zJfvHTiXr5TUsog4725vMHezYoLTlHE3o,7425
-py2dag/pseudo.py,sha256=NJK61slyFLtSjhj8gJDJneUInEpBN57_41g8IfHNPWI,922
-py2dag-0.1.4.dist-info/LICENSE,sha256=3Qee1EPwej_nusovTbyIQ8LvD2rXHdM0c6LNwk_D8Kc,1067
-py2dag-0.1.4.dist-info/METADATA,sha256=4x14DTr7S4WjsGT0ht4x-zalL_pwbD3ir1cOUtl8bSw,3308
-py2dag-0.1.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-py2dag-0.1.4.dist-info/entry_points.txt,sha256=Q0SHexJJ0z1te4AYL1xTZogx5FrxCCE1ZJ5qntkFMZs,42
-py2dag-0.1.4.dist-info/RECORD,,