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

abstractflow/__init__.py

@@ -1,104 +1,84 @@
+"""AbstractFlow - Multi-agent orchestration layer for the Abstract Framework.
+
+AbstractFlow enables composition of agents into pipelines and coordinates
+their execution via AbstractRuntime. It provides:
+
+- Flow: Declarative flow definition with nodes and edges
+- FlowRunner: High-level interface for running flows
+- compile_flow: Convert Flow to WorkflowSpec for direct runtime usage
+
+Example:
+    >>> from abstractflow import Flow, FlowRunner
+    >>>
+    >>> # Define a simple flow
+    >>> flow = Flow("my_pipeline")
+    >>> flow.add_node("step1", lambda x: x * 2, input_key="value", output_key="doubled")
+    >>> flow.add_node("step2", lambda x: x + 10, input_key="doubled", output_key="result")
+    >>> flow.add_edge("step1", "step2")
+    >>> flow.set_entry("step1")
+    >>>
+    >>> # Run the flow
+    >>> runner = FlowRunner(flow)
+    >>> result = runner.run({"value": 5})
+    >>> print(result)  # {'result': 20, 'success': True}
+
+For agent-based flows:
+    >>> from abstractflow import Flow, FlowRunner
+    >>> from abstractagent import create_react_agent
+    >>>
+    >>> planner = create_react_agent(provider="ollama", model="qwen3:4b")
+    >>> executor = create_react_agent(provider="ollama", model="qwen3:4b")
+    >>>
+    >>> flow = Flow("plan_and_execute")
+    >>> flow.add_node("plan", planner, output_key="plan")
+    >>> flow.add_node("execute", executor, input_key="plan")
+    >>> flow.add_edge("plan", "execute")
+    >>> flow.set_entry("plan")
+    >>>
+    >>> runner = FlowRunner(flow)
+    >>> result = runner.run({"context": {"task": "Build a REST API"}})
 """
-AbstractFlow - Diagram-based AI workflow generation.
 
-Built on top of AbstractCore for unified LLM provider access.
-"""
-
-__version__ = "0.1.0"
-__author__ = "AbstractFlow Team"
+__version__ = "0.3.1"
+__author__ = "Laurent-Philippe Albou"
 __email__ = "contact@abstractflow.ai"
 __license__ = "MIT"
 
-# Core imports that will be available when the package is fully implemented
-__all__ = [
-    "__version__",
-    "WorkflowBuilder",
-    "Node", 
-    "LLMNode",
-    "TextNode",
-    "ConditionalNode",
-    "TransformNode",
-]
-
-# Placeholder implementations - these will be replaced with actual implementations
-class WorkflowBuilder:
-    """
-    Visual workflow builder for creating AI-powered diagrams.
-    
-    This is a placeholder implementation. The full version will provide:
-    - Drag-and-drop workflow creation
-    - Real-time execution monitoring  
-    - Multi-provider LLM support via AbstractCore
-    - Export to various formats
-    """
-    
-    def __init__(self):
-        """Initialize a new workflow builder."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
-
-
-class Node:
-    """Base class for all workflow nodes."""
-    
-    def __init__(self, node_id: str):
-        """Initialize a workflow node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
+# Core classes
+from .core.flow import Flow, FlowNode, FlowEdge
 
+# Compiler
+from .compiler import compile_flow
 
-class LLMNode(Node):
-    """Node for LLM-based text generation and processing."""
-    
-    def __init__(self, provider: str, model: str, **kwargs):
-        """Initialize an LLM node with AbstractCore provider."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
+# Runner
+from .runner import FlowRunner
 
+# Adapters (for advanced usage)
+from .adapters import (
+    create_function_node_handler,
+    create_agent_node_handler,
+    create_subflow_node_handler,
+)
 
-class TextNode(Node):
-    """Node for text input/output operations."""
-    
-    def __init__(self, text_id: str):
-        """Initialize a text node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
-
-
-class ConditionalNode(Node):
-    """Node for conditional branching in workflows."""
-    
-    def __init__(self, condition: str):
-        """Initialize a conditional node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
-
-
-class TransformNode(Node):
-    """Node for data transformation operations."""
-    
-    def __init__(self, transform_func: str):
-        """Initialize a transform node."""
-        raise NotImplementedError(
-            "AbstractFlow is currently in development. "
-            "This placeholder package reserves the PyPI name. "
-            "Follow https://github.com/lpalbou/AbstractFlow for updates."
-        )
+__all__ = [
+    # Version info
+    "__version__",
+    "__author__",
+    "__email__",
+    "__license__",
+    # Core classes
+    "Flow",
+    "FlowNode",
+    "FlowEdge",
+    # Compiler
+    "compile_flow",
+    # Runner
+    "FlowRunner",
+    # Adapters
+    "create_function_node_handler",
+    "create_agent_node_handler",
+    "create_subflow_node_handler",
+]
 
 
 def get_version() -> str:
@@ -107,5 +87,5 @@ def get_version() -> str:
 
 
 def is_development_version() -> bool:
-    """Check if this is a development/placeholder version."""
-    return True  # This will be False in the actual implementation
+    """Check if this is a development version."""
+    return False  # Now implemented!

abstractflow/__main__.py

@@ -8,3 +8,5 @@ from .cli import main
 
 if __name__ == "__main__":
     exit(main())
+
+

abstractflow/adapters/__init__.py

@@ -0,0 +1,11 @@
+"""AbstractFlow adapters for converting handlers to workflow nodes."""
+
+from .function_adapter import create_function_node_handler
+from .agent_adapter import create_agent_node_handler
+from .subflow_adapter import create_subflow_node_handler
+
+__all__ = [
+    "create_function_node_handler",
+    "create_agent_node_handler",
+    "create_subflow_node_handler",
+]

abstractflow/adapters/agent_adapter.py

@@ -0,0 +1,5 @@
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.adapters.agent_adapter import *  # noqa: F401,F403

abstractflow/adapters/control_adapter.py

@@ -0,0 +1,5 @@
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.adapters.control_adapter import *  # noqa: F401,F403

abstractflow/adapters/effect_adapter.py

@@ -0,0 +1,5 @@
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.adapters.effect_adapter import *  # noqa: F401,F403

abstractflow/adapters/event_adapter.py

@@ -0,0 +1,5 @@
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.adapters.event_adapter import *  # noqa: F401,F403

abstractflow/adapters/function_adapter.py

@@ -0,0 +1,5 @@
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.adapters.function_adapter import *  # noqa: F401,F403

abstractflow/adapters/subflow_adapter.py

@@ -0,0 +1,5 @@
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.adapters.subflow_adapter import *  # noqa: F401,F403

abstractflow/adapters/variable_adapter.py

@@ -0,0 +1,5 @@
+"""Re-export: AbstractRuntime VisualFlow compiler adapter."""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.adapters.variable_adapter import *  # noqa: F401,F403

abstractflow/cli.py

@@ -1,42 +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())
+
+

abstractflow/compiler.py

@@ -0,0 +1,23 @@
+"""AbstractFlow compiler shim.
+
+AbstractFlow no longer owns workflow compilation semantics. The single source of
+truth for VisualFlow/Flow compilation lives in `abstractruntime.visualflow_compiler`.
+"""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.compiler import (
+    _create_visual_agent_effect_handler,
+    _sync_effect_results_to_node_outputs,
+    compile_flow,
+    compile_visualflow,
+    compile_visualflow_tree,
+)
+
+__all__ = [
+    "compile_flow",
+    "compile_visualflow",
+    "compile_visualflow_tree",
+    "_create_visual_agent_effect_handler",
+    "_sync_effect_results_to_node_outputs",
+]

abstractflow/core/__init__.py

@@ -0,0 +1,5 @@
+"""AbstractFlow core module."""
+
+from .flow import Flow, FlowNode, FlowEdge
+
+__all__ = ["Flow", "FlowNode", "FlowEdge"]

abstractflow/core/flow.py

@@ -0,0 +1,11 @@
+"""Flow definition classes for AbstractFlow.
+
+This module is a thin re-export of AbstractRuntime's Flow IR so there is a
+single semantics + IR surface shared across hosts.
+"""
+
+from __future__ import annotations
+
+from abstractruntime.visualflow_compiler.flow import Flow, FlowEdge, FlowNode
+
+__all__ = ["Flow", "FlowNode", "FlowEdge"]

abstractflow/py.typed

@@ -1 +1,3 @@
 # Marker file for PEP 561 - indicates this package supports type checking
+
+