duragraph-python 0.1.0__py3-none-any.whl

duragraph/__init__.py

@@ -0,0 +1,35 @@
+"""DuraGraph Python SDK - Reliable AI Workflow Orchestration."""
+
+from duragraph.edges import edge
+from duragraph.graph import Graph
+from duragraph.nodes import (
+    entrypoint,
+    human_node,
+    llm_node,
+    node,
+    router_node,
+    tool_node,
+)
+from duragraph.types import AIMessage, HumanMessage, Message, State, ToolMessage
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Graph
+    "Graph",
+    # Node decorators
+    "node",
+    "llm_node",
+    "tool_node",
+    "router_node",
+    "human_node",
+    "entrypoint",
+    # Edge
+    "edge",
+    # Types
+    "State",
+    "Message",
+    "HumanMessage",
+    "AIMessage",
+    "ToolMessage",
+]

duragraph/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI module for DuraGraph."""
+
+from duragraph.cli.main import main
+
+__all__ = ["main"]

duragraph/cli/main.py

@@ -0,0 +1,163 @@
+"""DuraGraph CLI entry point."""
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def main() -> int:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="duragraph",
+        description="DuraGraph Python SDK CLI",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # init command
+    init_parser = subparsers.add_parser("init", help="Initialize a new DuraGraph project")
+    init_parser.add_argument("name", help="Project name")
+    init_parser.add_argument(
+        "--template",
+        choices=["minimal", "full"],
+        default="minimal",
+        help="Project template",
+    )
+
+    # dev command
+    dev_parser = subparsers.add_parser("dev", help="Run in development mode")
+    dev_parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port for local server",
+    )
+    dev_parser.add_argument(
+        "--reload",
+        action="store_true",
+        help="Enable auto-reload",
+    )
+
+    # deploy command
+    deploy_parser = subparsers.add_parser("deploy", help="Deploy to control plane")
+    deploy_parser.add_argument(
+        "--control-plane",
+        required=True,
+        help="Control plane URL",
+    )
+    deploy_parser.add_argument(
+        "--graph",
+        help="Specific graph to deploy (default: all)",
+    )
+
+    # visualize command
+    viz_parser = subparsers.add_parser("visualize", help="Visualize a graph")
+    viz_parser.add_argument("file", help="Python file containing the graph")
+    viz_parser.add_argument(
+        "--output",
+        "-o",
+        help="Output file (default: stdout)",
+    )
+    viz_parser.add_argument(
+        "--format",
+        choices=["mermaid", "dot", "json"],
+        default="mermaid",
+        help="Output format",
+    )
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        return 0
+
+    if args.command == "init":
+        return cmd_init(args.name, args.template)
+    elif args.command == "dev":
+        return cmd_dev(args.port, args.reload)
+    elif args.command == "deploy":
+        return cmd_deploy(args.control_plane, args.graph)
+    elif args.command == "visualize":
+        return cmd_visualize(args.file, args.output, args.format)
+
+    return 0
+
+
+def cmd_init(name: str, template: str) -> int:
+    """Initialize a new project."""
+    project_dir = Path(name)
+    if project_dir.exists():
+        print(f"Error: Directory '{name}' already exists")
+        return 1
+
+    project_dir.mkdir(parents=True)
+
+    # Create basic structure
+    (project_dir / "src").mkdir()
+    (project_dir / "tests").mkdir()
+
+    # Create main agent file
+    agent_content = '''"""Example DuraGraph agent."""
+
+from duragraph import Graph, llm_node, entrypoint
+
+
+@Graph(id="example_agent")
+class ExampleAgent:
+    """A simple example agent."""
+
+    @entrypoint
+    @llm_node(model="gpt-4o-mini")
+    def process(self, state):
+        """Process the input."""
+        return state
+
+
+if __name__ == "__main__":
+    agent = ExampleAgent()
+    result = agent.run({"message": "Hello, world!"})
+    print(result)
+'''
+    (project_dir / "src" / "agent.py").write_text(agent_content)
+
+    # Create pyproject.toml
+    pyproject_content = f'''[project]
+name = "{name}"
+version = "0.1.0"
+dependencies = ["duragraph"]
+
+[tool.duragraph]
+control_plane = "http://localhost:8081"
+'''
+    (project_dir / "pyproject.toml").write_text(pyproject_content)
+
+    print(f"Created new DuraGraph project: {name}")
+    print("\nNext steps:")
+    print(f"  cd {name}")
+    print("  uv sync")
+    print("  duragraph dev")
+    return 0
+
+
+def cmd_dev(port: int, reload: bool) -> int:
+    """Run in development mode."""
+    print(f"Starting development server on port {port}...")
+    print("Development mode not yet implemented")
+    return 1
+
+
+def cmd_deploy(control_plane: str, graph: str | None) -> int:
+    """Deploy to control plane."""
+    print(f"Deploying to {control_plane}...")
+    print("Deployment not yet implemented")
+    return 1
+
+
+def cmd_visualize(file: str, output: str | None, format: str) -> int:
+    """Visualize a graph."""
+    print(f"Visualizing {file}...")
+    print("Visualization not yet implemented")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

duragraph/edges.py

@@ -0,0 +1,116 @@
+"""Edge definitions for DuraGraph workflows."""
+
+from collections.abc import Callable
+from typing import Any
+
+
+class Edge:
+    """Represents an edge between nodes in a graph."""
+
+    def __init__(
+        self,
+        source: str,
+        target: str | dict[str, str],
+        condition: Callable[[dict[str, Any]], bool] | None = None,
+    ):
+        self.source = source
+        self.target = target
+        self.condition = condition
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert edge to dictionary representation."""
+        result: dict[str, Any] = {
+            "source": self.source,
+            "target": self.target,
+        }
+        if self.condition is not None:
+            result["conditional"] = True
+        return result
+
+
+class EdgeBuilder:
+    """Builder for creating edges with fluent API."""
+
+    def __init__(self, source: str):
+        self.source = source
+        self._edges: list[Edge] = []
+
+    def to(
+        self,
+        target: str,
+        *,
+        condition: Callable[[dict[str, Any]], bool] | None = None,
+    ) -> "EdgeBuilder":
+        """Add an edge to a target node.
+
+        Args:
+            target: Name of the target node.
+            condition: Optional condition function that takes state and returns bool.
+
+        Returns:
+            Self for chaining.
+        """
+        self._edges.append(Edge(self.source, target, condition))
+        return self
+
+    def to_conditional(
+        self,
+        mapping: dict[str, str],
+    ) -> "EdgeBuilder":
+        """Add conditional edges based on router output.
+
+        Args:
+            mapping: Dictionary mapping router output values to node names.
+
+        Returns:
+            Self for chaining.
+        """
+        self._edges.append(Edge(self.source, mapping))
+        return self
+
+    def build(self) -> list[Edge]:
+        """Build and return all edges."""
+        return self._edges
+
+
+def edge(source: str) -> EdgeBuilder:
+    """Create an edge builder starting from a source node.
+
+    Args:
+        source: Name of the source node.
+
+    Returns:
+        EdgeBuilder for fluent edge construction.
+
+    Example:
+        # Simple edge
+        edge("classify").to("respond")
+
+        # Conditional edge
+        edge("router").to_conditional({
+            "billing": "billing_handler",
+            "support": "support_handler",
+        })
+    """
+    return EdgeBuilder(source)
+
+
+class NodeProxy:
+    """Proxy object for node methods that enables >> operator for edge definition."""
+
+    def __init__(self, name: str, graph: Any):
+        self._name = name
+        self._graph = graph
+
+    def __rshift__(self, other: "NodeProxy") -> "NodeProxy":
+        """Define an edge using >> operator.
+
+        Example:
+            classify >> respond
+        """
+        if self._graph is not None:
+            self._graph._add_edge(self._name, other._name)
+        return other
+
+    def __repr__(self) -> str:
+        return f"NodeProxy({self._name})"