abstractflow 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

abstractflow/adapters/variable_adapter.py

@@ -1,317 +1,5 @@
-"""Variable node adapters (Blueprint-style Get/Set Variable).
-
-Design goals:
-- Variables are stored durably in `run.vars` (so pause/resume works).
-- `Set Variable` must not clobber the visual pipeline `_last_output` (pass-through),
-  otherwise inserting it into a chain would destroy downstream inputs.
-"""
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
 
 from __future__ import annotations
 
-import json
-from typing import Any, Callable, Dict, Optional
-
-
-def _set_by_path(target: Dict[str, Any], dotted_key: str, value: Any) -> None:
-    """Set a dotted path on a dict, creating intermediate dicts as needed."""
-    parts = [p for p in dotted_key.split(".") if p]
-    if not parts:
-        raise ValueError("Variable name must be non-empty")
-    cur: Dict[str, Any] = target
-    for part in parts[:-1]:
-        nxt = cur.get(part)
-        if not isinstance(nxt, dict):
-            nxt = {}
-            cur[part] = nxt
-        cur = nxt
-    cur[parts[-1]] = value
-
-
-def _get_by_path(source: Dict[str, Any], dotted_key: str) -> Any:
-    """Best-effort dotted-path lookup supporting dicts (and nested dicts).
-
-    This is intentionally conservative: workflow variables (`run.vars`) are dict-like state.
-    """
-    parts = [p for p in str(dotted_key or "").split(".") if p]
-    if not parts:
-        return None
-    current: Any = source
-    for part in parts:
-        if not isinstance(current, dict):
-            return None
-        current = current.get(part)
-    return current
-
-
-def _set_on_object(obj: Dict[str, Any], dotted_key: str, value: Any) -> Dict[str, Any]:
-    """Set a nested key on an object dict (mutates the given dict) and return it."""
-    parts = [p for p in str(dotted_key or "").split(".") if p]
-    if not parts:
-        return obj
-    cur: Dict[str, Any] = obj
-    for part in parts[:-1]:
-        nxt = cur.get(part)
-        if not isinstance(nxt, dict):
-            nxt = {}
-            cur[part] = nxt
-        cur = nxt
-    cur[parts[-1]] = value
-    return obj
-
-
-def _persist_node_output(run_vars: Dict[str, Any], node_id: str, value: Dict[str, Any]) -> None:
-    temp = run_vars.get("_temp")
-    if not isinstance(temp, dict):
-        temp = {}
-        run_vars["_temp"] = temp
-    persisted = temp.get("node_outputs")
-    if not isinstance(persisted, dict):
-        persisted = {}
-        temp["node_outputs"] = persisted
-    persisted[node_id] = value
-
-
-def create_set_var_node_handler(
-    *,
-    node_id: str,
-    next_node: Optional[str],
-    data_aware_handler: Optional[Callable[[Any], Any]],
-    flow: Any,
-) -> Callable:
-    """Create a handler for `set_var` visual nodes."""
-    from abstractruntime.core.models import StepPlan
-    from abstractflow.compiler import _sync_effect_results_to_node_outputs
-
-    def handler(run: Any, ctx: Any) -> "StepPlan":
-        del ctx
-        if flow is not None and hasattr(flow, "_node_outputs") and hasattr(flow, "_data_edge_map"):
-            _sync_effect_results_to_node_outputs(run, flow)
-
-        last_output = run.vars.get("_last_output", {})
-        resolved = data_aware_handler(last_output) if callable(data_aware_handler) else {}
-        payload = resolved if isinstance(resolved, dict) else {}
-
-        raw_name = payload.get("name")
-        name = (raw_name if isinstance(raw_name, str) else str(raw_name or "")).strip()
-        if not name:
-            run.vars["_flow_error"] = "Set Variable requires a non-empty variable name."
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-        if name.startswith("_"):
-            run.vars["_flow_error"] = f"Invalid variable name '{name}': names starting with '_' are reserved."
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-
-        value = payload.get("value")
-
-        try:
-            if not isinstance(run.vars, dict):
-                raise ValueError("run.vars is not a dict")
-            _set_by_path(run.vars, name, value)
-        except Exception as e:
-            run.vars["_flow_error"] = f"Failed to set variable '{name}': {e}"
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-
-        # Persist this node's outputs for pause/resume (data edges may depend on them).
-        _persist_node_output(run.vars, node_id, {"value": value})
-
-        # IMPORTANT: pass-through semantics (do NOT clobber the pipeline output).
-        # `_last_output` stays as-is.
-
-        if next_node:
-            return StepPlan(node_id=node_id, next_node=next_node)
-        return StepPlan(node_id=node_id, complete_output={"success": True, "result": run.vars.get("_last_output")})
-
-    return handler
-
-
-def create_set_var_property_node_handler(
-    *,
-    node_id: str,
-    next_node: Optional[str],
-    data_aware_handler: Optional[Callable[[Any], Any]],
-    flow: Any,
-) -> Callable:
-    """Create a handler for `set_var_property` visual nodes.
-
-    Contract:
-    - Inputs:
-      - `name`: base variable path (e.g. "state" or "state.player")
-      - `key`: nested key path inside that variable's object (e.g. "hp" or "stats.hp")
-      - `value`: value to set at `key`
-    - Behavior:
-      - reads current object at `name` (defaults to `{}` if missing/not an object)
-      - applies the update to a copy
-      - writes the updated object back into `run.vars[name]` (durable)
-      - persists node outputs for pause/resume
-      - does NOT clobber `_last_output` (pass-through)
-    """
-    from abstractruntime.core.models import StepPlan
-    from abstractflow.compiler import _sync_effect_results_to_node_outputs
-
-    def handler(run: Any, ctx: Any) -> "StepPlan":
-        del ctx
-        if flow is not None and hasattr(flow, "_node_outputs") and hasattr(flow, "_data_edge_map"):
-            _sync_effect_results_to_node_outputs(run, flow)
-
-        last_output = run.vars.get("_last_output", {})
-        resolved = data_aware_handler(last_output) if callable(data_aware_handler) else {}
-        payload = resolved if isinstance(resolved, dict) else {}
-
-        raw_name = payload.get("name")
-        name = (raw_name if isinstance(raw_name, str) else str(raw_name or "")).strip()
-        if not name:
-            run.vars["_flow_error"] = "Set Variable Property requires a non-empty variable name."
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-        if name.startswith("_"):
-            run.vars["_flow_error"] = f"Invalid variable name '{name}': names starting with '_' are reserved."
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-
-        raw_key = payload.get("key")
-        key = (raw_key if isinstance(raw_key, str) else str(raw_key or "")).strip()
-        if not key:
-            run.vars["_flow_error"] = "Set Variable Property requires a non-empty key."
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-
-        value = payload.get("value")
-
-        try:
-            if not isinstance(run.vars, dict):
-                raise ValueError("run.vars is not a dict")
-
-            current = _get_by_path(run.vars, name)
-            base_obj: Dict[str, Any] = dict(current) if isinstance(current, dict) else {}
-            _set_on_object(base_obj, key, value)
-            _set_by_path(run.vars, name, base_obj)
-        except Exception as e:
-            run.vars["_flow_error"] = f"Failed to set variable property '{name}.{key}': {e}"
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-
-        # Persist this node's outputs for pause/resume (data edges may depend on them).
-        _persist_node_output(run.vars, node_id, {"value": base_obj})
-
-        # IMPORTANT: pass-through semantics (do NOT clobber the pipeline output).
-        # `_last_output` stays as-is.
-        if next_node:
-            return StepPlan(node_id=node_id, next_node=next_node)
-        return StepPlan(node_id=node_id, complete_output={"success": True, "value": base_obj, "result": run.vars.get("_last_output")})
-
-    return handler
-
-
-def create_set_vars_node_handler(
-    *,
-    node_id: str,
-    next_node: Optional[str],
-    data_aware_handler: Optional[Callable[[Any], Any]],
-    flow: Any,
-) -> Callable:
-    """Create a handler for `set_vars` visual nodes.
-
-    Contract:
-    - Input pin: `updates` (object or JSON string), where keys are dotted paths and values are JSON-safe values.
-    - Output pin: `updates` (echoed), for observability/debugging.
-    - Pass-through: must NOT clobber `_last_output` (same as `set_var`).
-    """
-    from abstractruntime.core.models import StepPlan
-    from abstractflow.compiler import _sync_effect_results_to_node_outputs
-
-    def _coerce_updates(raw: Any) -> Dict[str, Any]:
-        if isinstance(raw, dict):
-            return dict(raw)
-        if isinstance(raw, str) and raw.strip():
-            try:
-                parsed = json.loads(raw)
-            except Exception:
-                return {}
-            return dict(parsed) if isinstance(parsed, dict) else {}
-        return {}
-
-    def handler(run: Any, ctx: Any) -> "StepPlan":
-        del ctx
-        if flow is not None and hasattr(flow, "_node_outputs") and hasattr(flow, "_data_edge_map"):
-            _sync_effect_results_to_node_outputs(run, flow)
-
-        last_output = run.vars.get("_last_output", {})
-        resolved = data_aware_handler(last_output) if callable(data_aware_handler) else {}
-        payload = resolved if isinstance(resolved, dict) else {}
-
-        updates = _coerce_updates(payload.get("updates"))
-        if not updates:
-            # Deterministic no-op (still counts as a step, but doesn't pollute `_flow_error`).
-            _persist_node_output(run.vars, node_id, {"updates": {}})
-            if next_node:
-                return StepPlan(node_id=node_id, next_node=next_node)
-            return StepPlan(node_id=node_id, complete_output={"success": True, "updates": {}, "result": run.vars.get("_last_output")})
-
-        # Validate all keys first so we don't partially apply.
-        normalized: Dict[str, Any] = {}
-        for k, v in updates.items():
-            name = (k if isinstance(k, str) else str(k or "")).strip()
-            if not name:
-                run.vars["_flow_error"] = "Set Variables requires non-empty variable names in updates."
-                run.vars["_flow_error_node"] = node_id
-                return StepPlan(
-                    node_id=node_id,
-                    complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-                )
-            if name.startswith("_"):
-                run.vars["_flow_error"] = f"Invalid variable name '{name}': names starting with '_' are reserved."
-                run.vars["_flow_error_node"] = node_id
-                return StepPlan(
-                    node_id=node_id,
-                    complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-                )
-            normalized[name] = v
-
-        try:
-            if not isinstance(run.vars, dict):
-                raise ValueError("run.vars is not a dict")
-            for name, value in normalized.items():
-                _set_by_path(run.vars, name, value)
-        except Exception as e:
-            run.vars["_flow_error"] = f"Failed to set variables: {e}"
-            run.vars["_flow_error_node"] = node_id
-            return StepPlan(
-                node_id=node_id,
-                complete_output={"success": False, "error": run.vars["_flow_error"], "node": node_id},
-            )
-
-        # Persist this node's outputs for pause/resume (data edges may depend on them).
-        _persist_node_output(run.vars, node_id, {"updates": normalized})
-
-        # IMPORTANT: pass-through semantics (do NOT clobber the pipeline output).
-        # `_last_output` stays as-is.
-        if next_node:
-            return StepPlan(node_id=node_id, next_node=next_node)
-        return StepPlan(node_id=node_id, complete_output={"success": True, "updates": normalized, "result": run.vars.get("_last_output")})
-
-    return handler
-
-
+from abstractruntime.visualflow_compiler.adapters.variable_adapter import *  # noqa: F401,F403

abstractflow/cli.py

@@ -1,44 +1,89 @@
-"""
-Command-line interface for AbstractFlow.
+"""Command-line interface for AbstractFlow.
+
+Current implemented features:
+- WorkflowBundle (.flow) pack/inspect/unpack (backlog 314)
 
-This is a placeholder CLI that will be expanded in future versions.
+Other commands are intentionally kept minimal for now.
 """
 
+from __future__ import annotations
+
+import argparse
+import json
 import sys
 from typing import List, Optional
 
+from .workflow_bundle import inspect_workflow_bundle, pack_workflow_bundle, unpack_workflow_bundle
+from abstractruntime.workflow_bundle import workflow_bundle_manifest_to_dict
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="abstractflow", add_help=True)
+    sub = p.add_subparsers(dest="command")
+
+    bundle = sub.add_parser("bundle", help="WorkflowBundle (.flow) tools")
+    bundle_sub = bundle.add_subparsers(dest="bundle_cmd")
+
+    pack = bundle_sub.add_parser("pack", help="Pack a .flow bundle from a root VisualFlow JSON file")
+    pack.add_argument("root", help="Path to root VisualFlow JSON (e.g., ./flows/<id>.json)")
+    pack.add_argument("--out", required=True, help="Output .flow path")
+    pack.add_argument("--bundle-id", default=None, help="Bundle id (default: root flow id)")
+    pack.add_argument("--bundle-version", default="0.0.0", help="Bundle version (default: 0.0.0)")
+    pack.add_argument("--flows-dir", default=None, help="Directory containing flow JSON files (default: root's directory)")
+    pack.add_argument(
+        "--entrypoint",
+        action="append",
+        default=None,
+        help="Entrypoint flow id (repeatable). Default: root flow id",
+    )
+
+    insp = bundle_sub.add_parser("inspect", help="Print bundle manifest (JSON)")
+    insp.add_argument("bundle", help="Path to .flow (zip) or extracted directory")
+
+    unpack = bundle_sub.add_parser("unpack", help="Extract a .flow bundle to a directory")
+    unpack.add_argument("bundle", help="Path to .flow (zip) or extracted directory")
+    unpack.add_argument("--dir", required=True, help="Output directory")
+
+    return p
+
 
 def main(args: Optional[List[str]] = None) -> int:
-    """
-    Main entry point for the AbstractFlow CLI.
-    
-    Args:
-        args: Command-line arguments (defaults to sys.argv[1:])
-        
-    Returns:
-        Exit code (0 for success, non-zero for error)
-    """
     if args is None:
         args = sys.argv[1:]
-    
-    print("🚧 AbstractFlow CLI - Coming Soon!")
-    print()
-    print("AbstractFlow is currently in development.")
-    print("This placeholder package reserves the PyPI name.")
-    print()
-    print("Planned CLI features:")
-    print("  • abstractflow create <workflow>    - Create new workflow")
-    print("  • abstractflow run <workflow>       - Execute workflow")
-    print("  • abstractflow validate <workflow>  - Validate workflow")
-    print("  • abstractflow export <workflow>    - Export workflow")
-    print("  • abstractflow serve               - Start workflow server")
-    print()
-    print("Follow https://github.com/lpalbou/AbstractFlow for updates!")
-    
+
+    parser = _build_parser()
+    ns = parser.parse_args(args)
+
+    if ns.command == "bundle":
+        if ns.bundle_cmd == "pack":
+            packed = pack_workflow_bundle(
+                root_flow_json=ns.root,
+                out_path=ns.out,
+                bundle_id=ns.bundle_id,
+                bundle_version=ns.bundle_version,
+                flows_dir=ns.flows_dir,
+                entrypoints=list(ns.entrypoint) if isinstance(ns.entrypoint, list) and ns.entrypoint else None,
+            )
+            sys.stdout.write(str(packed.path) + "\n")
+            return 0
+
+        if ns.bundle_cmd == "inspect":
+            man = inspect_workflow_bundle(bundle_path=ns.bundle)
+            sys.stdout.write(json.dumps(workflow_bundle_manifest_to_dict(man), indent=2, ensure_ascii=False) + "\n")
+            return 0
+
+        if ns.bundle_cmd == "unpack":
+            out = unpack_workflow_bundle(bundle_path=ns.bundle, out_dir=ns.dir)
+            sys.stdout.write(str(out) + "\n")
+            return 0
+
+        parser.error("Missing bundle subcommand (pack|inspect|unpack)")
+
+    parser.print_help()
     return 0
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    raise SystemExit(main())