pyoco 0.1.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

pyoco/cli/main.py

@@ -1,11 +1,16 @@
 import argparse
+import json
 import sys
 import os
+import signal
+import time
 from ..schemas.config import PyocoConfig
 from ..discovery.loader import TaskLoader
 from ..core.models import Flow
 from ..core.engine import Engine
 from ..trace.console import ConsoleTraceBackend
+from ..client import Client
+from ..discovery.plugins import list_available_plugins
 
 def main():
     parser = argparse.ArgumentParser(description="Pyoco Workflow Engine")
@@ -20,54 +25,220 @@ def main():
     run_parser.add_argument("--non-cute", action="store_false", dest="cute", help="Use plain trace style")
     # Allow overriding params via CLI
     run_parser.add_argument("--param", action="append", help="Override params (key=value)")
+    run_parser.add_argument("--server", help="Server URL for remote execution")
 
     # Check command
     check_parser = subparsers.add_parser("check", help="Verify a workflow")
     check_parser.add_argument("--config", required=True, help="Path to flow.yaml")
     check_parser.add_argument("--flow", default="main", help="Flow name to check")
+    check_parser.add_argument("--dry-run", action="store_true", help="Traverse flow without executing tasks")
+    check_parser.add_argument("--json", action="store_true", help="Output report as JSON")
 
     # List tasks command
     list_parser = subparsers.add_parser("list-tasks", help="List available tasks")
     list_parser.add_argument("--config", required=True, help="Path to flow.yaml")
 
+    # Server command
+    server_parser = subparsers.add_parser("server", help="Manage Kanban Server")
+    server_subparsers = server_parser.add_subparsers(dest="server_command")
+    server_start = server_subparsers.add_parser("start", help="Start the server")
+    server_start.add_argument("--host", default="0.0.0.0", help="Host to bind")
+    server_start.add_argument("--port", type=int, default=8000, help="Port to bind")
+
+    # Worker command
+    worker_parser = subparsers.add_parser("worker", help="Manage Worker")
+    worker_subparsers = worker_parser.add_subparsers(dest="worker_command")
+    worker_start = worker_subparsers.add_parser("start", help="Start a worker")
+    worker_start.add_argument("--server", required=True, help="Server URL")
+    worker_start.add_argument("--config", required=True, help="Path to flow.yaml")
+    worker_start.add_argument("--tags", help="Comma-separated tags")
+
+    # Runs command
+    runs_parser = subparsers.add_parser("runs", help="Manage runs")
+    runs_subparsers = runs_parser.add_subparsers(dest="runs_command")
+    
+    runs_list = runs_subparsers.add_parser("list", help="List runs")
+    runs_list.add_argument("--server", default="http://localhost:8000", help="Server URL")
+    runs_list.add_argument("--status", help="Filter by status")
+    runs_list.add_argument("--flow", help="Filter by flow name")
+    runs_list.add_argument("--limit", type=int, help="Maximum number of runs to show")
+    
+    runs_show = runs_subparsers.add_parser("show", help="Show run details")
+    runs_show.add_argument("run_id", help="Run ID")
+    runs_show.add_argument("--server", default="http://localhost:8000", help="Server URL")
+    
+    runs_cancel = runs_subparsers.add_parser("cancel", help="Cancel a run")
+    runs_cancel.add_argument("run_id", help="Run ID")
+    runs_cancel.add_argument("--server", default="http://localhost:8000", help="Server URL")
+    
+    runs_inspect = runs_subparsers.add_parser("inspect", help="Inspect run details")
+    runs_inspect.add_argument("run_id", help="Run ID")
+    runs_inspect.add_argument("--server", default="http://localhost:8000", help="Server URL")
+    runs_inspect.add_argument("--json", action="store_true", help="Output JSON payload")
+    
+    runs_logs = runs_subparsers.add_parser("logs", help="Show run logs")
+    runs_logs.add_argument("run_id", help="Run ID")
+    runs_logs.add_argument("--server", default="http://localhost:8000", help="Server URL")
+    runs_logs.add_argument("--task", help="Filter logs by task")
+    runs_logs.add_argument("--tail", type=int, help="Show last N log entries")
+    runs_logs.add_argument("--follow", action="store_true", help="Stream logs until completion")
+    runs_logs.add_argument("--allow-failure", action="store_true", help="Don't exit non-zero when run failed")
+
+    plugins_parser = subparsers.add_parser("plugins", help="Inspect plug-in entry points")
+    plugins_sub = plugins_parser.add_subparsers(dest="plugins_command")
+    plugins_list = plugins_sub.add_parser("list", help="List discovered plug-ins")
+    plugins_list.add_argument("--json", action="store_true", help="Output JSON payload")
+
     args = parser.parse_args()
 
     if not args.command:
         parser.print_help()
         sys.exit(1)
 
-    # Load config
-    try:
-        config = PyocoConfig.from_yaml(args.config)
-    except Exception as e:
-        print(f"Error loading config: {e}")
-        sys.exit(1)
+    # Load config only if needed
+    config = None
+    if hasattr(args, 'config') and args.config:
+        try:
+            config = PyocoConfig.from_yaml(args.config)
+        except Exception as e:
+            print(f"Error loading config: {e}")
+            sys.exit(1)
 
-    # Discover tasks
-    loader = TaskLoader(config)
-    loader.load()
+    # Discover tasks only if config is loaded
+    loader = None
+    if config:
+        loader = TaskLoader(config)
+        loader.load()
 
     if args.command == "list-tasks":
+        if not loader:
+             print("Error: Config not loaded.")
+             sys.exit(1)
         print("Available tasks:")
         for name in loader.tasks:
             print(f" - {name}")
         return
 
+    if args.command == "plugins":
+        infos = list_available_plugins()
+        if args.plugins_command == "list":
+            if getattr(args, "json", False):
+                print(json.dumps(infos, indent=2))
+            else:
+                if not infos:
+                    print("No plug-ins registered under group 'pyoco.tasks'.")
+                else:
+                    print("Discovered plug-ins:")
+                    for info in infos:
+                        mod = info.get("module") or info.get("value")
+                        print(f" - {info.get('name')} ({mod})")
+        return
+
+    if args.command == "server":
+        if args.server_command == "start":
+            import uvicorn
+            print(f"🐇 Starting Kanban Server on {args.host}:{args.port}")
+            uvicorn.run("pyoco.server.api:app", host=args.host, port=args.port, log_level="info")
+        return
+
+    if args.command == "worker":
+        if args.worker_command == "start":
+            from ..worker.runner import Worker
+            tags = args.tags.split(",") if args.tags else []
+            worker = Worker(args.server, config, tags)
+            worker.start()
+        return
+
+    if args.command == "runs":
+        client = Client(args.server)
+        try:
+            if args.runs_command == "list":
+                runs = client.list_runs(status=args.status, flow=args.flow, limit=args.limit)
+                print(f"🐇 Active Runs ({len(runs)}):")
+                print(f"{'ID':<36} | {'Status':<12} | {'Flow':<15}")
+                print("-" * 70)
+                for r in runs:
+                    # RunContext doesn't have flow_name in core model, but store adds it.
+                    # We need to access it safely.
+                    flow_name = r.get("flow_name", "???")
+                    print(f"{r['run_id']:<36} | {r['status']:<12} | {flow_name:<15}")
+            
+            elif args.runs_command == "show":
+                run = client.get_run(args.run_id)
+                print(f"🐇 Run: {run['run_id']}")
+                print(f"Status: {run['status']}")
+                print("Tasks:")
+                for t_name, t_state in run.get("tasks", {}).items():
+                    print(f"  [{t_state}] {t_name}")
+            
+            elif args.runs_command == "cancel":
+                client.cancel_run(args.run_id)
+                print(f"🛑 Cancellation requested for run {args.run_id}")
+            elif args.runs_command == "inspect":
+                run = client.get_run(args.run_id)
+                if args.json:
+                    print(json.dumps(run, indent=2))
+                else:
+                    print(f"🐇 Run: {run['run_id']} ({run.get('flow_name', 'n/a')})")
+                    print(f"Status: {run['status']}")
+                    if run.get("start_time"):
+                        print(f"Started: {run['start_time']}")
+                    if run.get("end_time"):
+                        print(f"Ended: {run['end_time']}")
+                    print("Tasks:")
+                    records = run.get("task_records", {})
+                    for name, info in records.items():
+                        state = info.get("state", run["tasks"].get(name))
+                        duration = info.get("duration_ms")
+                        duration_str = f"{duration:.2f} ms" if duration else "-"
+                        print(f"  - {name}: {state} ({duration_str})")
+                        if info.get("error"):
+                            print(f"      error: {info['error']}")
+                    if not records:
+                        for t_name, t_state in run.get("tasks", {}).items():
+                            print(f"  - {t_name}: {t_state}")
+            elif args.runs_command == "logs":
+                _stream_logs(client, args)
+        except Exception as e:
+            print(f"Error: {e}")
+        return
+
     if args.command == "run":
         flow_conf = config.flows.get(args.flow)
         if not flow_conf:
             print(f"Flow '{args.flow}' not found in config.")
             sys.exit(1)
         
+        # Params
+        params = flow_conf.defaults.copy()
+        if args.param:
+            for p in args.param:
+                if "=" in p:
+                    k, v = p.split("=", 1)
+                    params[k] = v # Simple string parsing for now
+
+        if args.server:
+            # Remote execution
+            client = Client(args.server)
+            try:
+                run_id = client.submit_run(args.flow, params)
+                print(f"🚀 Flow submitted! Run ID: {run_id}")
+                print(f"📋 View status: pyoco runs show {run_id} --server {args.server}")
+            except Exception as e:
+                print(f"Error submitting flow: {e}")
+                sys.exit(1)
+            return
         # Build Flow from graph string
-        from ..dsl.syntax import TaskWrapper
+        from ..dsl.syntax import TaskWrapper, switch
         eval_context = {name: TaskWrapper(task) for name, task in loader.tasks.items()}
+        eval_context["switch"] = switch
         
         try:
             # Create Flow and add all loaded tasks
             flow = Flow(name=args.flow)
             for t in loader.tasks.values():
                 flow.add_task(t)
+            eval_context["flow"] = flow
 
             # Evaluate graph to set up dependencies
             exec(flow_conf.graph, {}, eval_context)
@@ -76,13 +247,15 @@ def main():
             backend = ConsoleTraceBackend(style="cute" if args.cute else "plain")
             engine = Engine(trace_backend=backend)
             
-            # Params
-            params = flow_conf.defaults.copy()
-            if args.param:
-                for p in args.param:
-                    if "=" in p:
-                        k, v = p.split("=", 1)
-                        params[k] = v # Simple string parsing for now
+            # Params (Moved up)
+            
+            # Signal handler for cancellation
+            def signal_handler(sig, frame):
+                print("\n🛑 Ctrl+C detected. Cancelling active runs...")
+                for rid in list(engine.active_runs.keys()):
+                    engine.cancel(rid)
+            
+            signal.signal(signal.SIGINT, signal_handler)
             
             engine.run(flow, params)
             
@@ -104,36 +277,36 @@ def main():
 
         # 1. Check imports (already done by loader.load(), but we can check for missing tasks in graph)
         # 2. Build flow to check graph
-        from ..dsl.syntax import TaskWrapper
+        from ..dsl.syntax import TaskWrapper, switch
         eval_context = {name: TaskWrapper(task) for name, task in loader.tasks.items()}
+        eval_context["switch"] = switch
         
         try:
             flow = Flow(name=args.flow)
             for t in loader.tasks.values():
                 flow.add_task(t)
+            eval_context["flow"] = flow
             
             eval(flow_conf.graph, {}, eval_context)
             
             # 3. Reachability / Orphans
-            # Nodes with no deps and no dependents (except if single node flow)
             if len(flow.tasks) > 1:
                 for t in flow.tasks:
                     if not t.dependencies and not t.dependents:
                         warnings.append(f"Task '{t.name}' is orphaned (no dependencies or dependents).")
 
             # 4. Cycles
-            # Simple DFS for cycle detection
             visited = set()
             path = set()
+
             def visit(node):
                 if node in path:
-                    return True # Cycle
+                    return True
                 if node in visited:
                     return False
-                
                 visited.add(node)
                 path.add(node)
-                for dep in node.dependencies: # Check upstream
+                for dep in node.dependencies:
                     if visit(dep):
                         return True
                 path.remove(node)
@@ -149,29 +322,75 @@ def main():
             for t in flow.tasks:
                 sig = inspect.signature(t.func)
                 for name, param in sig.parameters.items():
-                    if name == 'ctx': continue
-                    # Check if input provided in task config or defaults
-                    # This is hard because inputs are resolved at runtime.
-                    # But we can check if 'inputs' mapping exists for it.
+                    if name == 'ctx': 
+                        continue
                     if name not in t.inputs and name not in flow_conf.defaults:
-                        # Warning: might be missing input
                         warnings.append(f"Task '{t.name}' argument '{name}' might be missing input (not in inputs or defaults).")
 
         except Exception as e:
             errors.append(f"Graph evaluation failed: {e}")
 
-        # Report
-        print("\n--- Check Report ---")
-        if not errors and not warnings:
-            print("✅ All checks passed!")
+        if args.dry_run:
+            from ..dsl.validator import FlowValidator
+            try:
+                validator = FlowValidator(flow)
+                dr_report = validator.validate()
+                warnings.extend(dr_report.warnings)
+                errors.extend(dr_report.errors)
+            except Exception as exc:
+                print(f"❌ Dry run internal error: {exc}")
+                import traceback
+                traceback.print_exc()
+                sys.exit(3)
+
+        status = "ok"
+        if errors:
+            status = "error"
+        elif warnings:
+            status = "warning"
+
+        report = {"status": status, "warnings": warnings, "errors": errors}
+
+        if args.json:
+            print(json.dumps(report, indent=2))
         else:
-            for w in warnings:
-                print(f"⚠️  {w}")
-            for e in errors:
-                print(f"❌ {e}")
-            
-            if errors:
+            print("\n--- Check Report ---")
+            print(f"Status: {status}")
+            if not errors and not warnings:
+                print("✅ All checks passed!")
+            else:
+                for w in warnings:
+                    print(f"⚠️  {w}")
+                for e in errors:
+                    print(f"❌ {e}")
+        
+        if errors:
+            sys.exit(2 if args.dry_run else 1)
+        return
+
+def _stream_logs(client, args):
+    seen_seq = -1
+    follow = args.follow
+    while True:
+        tail = args.tail if (args.tail and seen_seq == -1 and not follow) else None
+        data = client.get_run_logs(args.run_id, task=args.task, tail=tail)
+        logs = data.get("logs", [])
+        logs.sort(key=lambda entry: entry.get("seq", 0))
+        for entry in logs:
+            seq = entry.get("seq", 0)
+            if seq <= seen_seq:
+                continue
+            line = entry.get("text", "")
+            line = line.rstrip("\n")
+            print(f"[{entry.get('task', 'unknown')}][{entry.get('stream', '')}] {line}")
+            seen_seq = seq
+        status = data.get("run_status", "UNKNOWN")
+        if not follow or status in ("COMPLETED", "FAILED", "CANCELLED"):
+            if status == "FAILED" and not args.allow_failure:
                 sys.exit(1)
+            break
+        time.sleep(1)
+
 
 if __name__ == "__main__":
     main()

pyoco/client.py

@@ -0,0 +1,89 @@
+import httpx
+from typing import Dict, List, Optional, Any
+from .core.models import RunStatus, TaskState, RunContext
+
+class Client:
+    def __init__(self, server_url: str, client_id: str = "cli"):
+        self.server_url = server_url.rstrip("/")
+        self.client_id = client_id
+        self.client = httpx.Client(base_url=self.server_url)
+
+    def submit_run(self, flow_name: str, params: Dict[str, Any], tags: List[str] = []) -> str:
+        resp = self.client.post("/runs", json={
+            "flow_name": flow_name,
+            "params": params,
+            "tags": tags
+        })
+        resp.raise_for_status()
+        return resp.json()["run_id"]
+
+    def list_runs(
+        self,
+        status: Optional[str] = None,
+        flow: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> List[Dict]:
+        params = {}
+        if status:
+            params["status"] = status
+        if flow:
+            params["flow"] = flow
+        if limit:
+            params["limit"] = limit
+        resp = self.client.get("/runs", params=params)
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_run(self, run_id: str) -> Dict:
+        resp = self.client.get(f"/runs/{run_id}")
+        resp.raise_for_status()
+        return resp.json()
+
+    def cancel_run(self, run_id: str):
+        resp = self.client.post(f"/runs/{run_id}/cancel")
+        resp.raise_for_status()
+
+    def poll(self, tags: List[str] = []) -> Optional[Dict[str, Any]]:
+        try:
+            resp = self.client.post("/workers/poll", json={
+                "worker_id": self.client_id,
+                "tags": tags
+            })
+            resp.raise_for_status()
+            data = resp.json()
+            if data.get("run_id"):
+                return data
+            return None
+        except Exception as e:
+            # print(f"Poll failed: {e}")
+            return None
+
+    def heartbeat(self, run_ctx: RunContext) -> bool:
+        """
+        Sends heartbeat. Returns True if cancellation is requested.
+        """
+        try:
+            states_json = {k: v.value if hasattr(v, 'value') else v for k, v in run_ctx.tasks.items()}
+            status_value = run_ctx.status.value if hasattr(run_ctx.status, 'value') else run_ctx.status
+            payload = {
+                "task_states": states_json,
+                "task_records": run_ctx.serialize_task_records(),
+                "logs": run_ctx.drain_logs(),
+                "run_status": status_value
+            }
+            resp = self.client.post(f"/runs/{run_ctx.run_id}/heartbeat", json=payload)
+            resp.raise_for_status()
+            return resp.json().get("cancel_requested", False)
+        except Exception as e:
+            print(f"Heartbeat failed: {e}")
+            return False
+
+    def get_run_logs(self, run_id: str, task: Optional[str] = None, tail: Optional[int] = None) -> Dict[str, Any]:
+        params = {}
+        if task:
+            params["task"] = task
+        if tail:
+            params["tail"] = tail
+        resp = self.client.get(f"/runs/{run_id}/logs", params=params)
+        resp.raise_for_status()
+        return resp.json()

pyoco/core/context.py

@@ -1,21 +1,100 @@
 import threading
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Sequence
 from dataclasses import dataclass, field
+from .models import RunContext
+
+
+@dataclass
+class LoopFrame:
+    name: str
+    type: str
+    index: Optional[int] = None
+    iteration: Optional[int] = None
+    count: Optional[int] = None
+    item: Any = None
+    condition: Optional[bool] = None
+    path: Optional[str] = None
+
+
+class LoopStack:
+    def __init__(self):
+        self._frames: List[LoopFrame] = []
+
+    def push(self, frame: LoopFrame) -> LoopFrame:
+        parent_path = self._frames[-1].path if self._frames else ""
+        segment = frame.name
+        if frame.index is not None:
+            segment = f"{segment}[{frame.index}]"
+        frame.path = f"{parent_path}.{segment}" if parent_path else segment
+        self._frames.append(frame)
+        return frame
+
+    def pop(self) -> LoopFrame:
+        if not self._frames:
+            raise RuntimeError("Loop stack underflow")
+        return self._frames.pop()
+
+    @property
+    def current(self) -> Optional[LoopFrame]:
+        return self._frames[-1] if self._frames else None
+
+    def snapshot(self) -> Sequence[LoopFrame]:
+        return tuple(self._frames)
 
 @dataclass
 class Context:
+    """
+    Execution context passed to tasks.
+    """
     params: Dict[str, Any] = field(default_factory=dict)
-    env: Dict[str, str] = field(default_factory=dict)
     results: Dict[str, Any] = field(default_factory=dict)
     scratch: Dict[str, Any] = field(default_factory=dict)
     artifacts: Dict[str, Any] = field(default_factory=dict)
-    run_id: Optional[str] = None
-    artifact_dir: str = field(default="./artifacts")
+    env: Dict[str, str] = field(default_factory=dict)
+    artifact_dir: Optional[str] = None
+    _vars: Dict[str, Any] = field(default_factory=dict, repr=False)
+    
+    # Reference to the parent run context (v0.2.0+)
+    run_context: Optional[RunContext] = None
     
     _lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
+    _loop_stack: LoopStack = field(default_factory=LoopStack, repr=False)
+
+    @property
+    def is_cancelled(self) -> bool:
+        if self.run_context:
+            from .models import RunStatus
+            return self.run_context.status in [RunStatus.CANCELLING, RunStatus.CANCELLED]
+        return False
+
+    @property
+    def loop(self) -> Optional[LoopFrame]:
+        return self._loop_stack.current
+
+    @property
+    def loops(self) -> Sequence[LoopFrame]:
+        return self._loop_stack.snapshot()
+
+    def push_loop(self, frame: LoopFrame) -> LoopFrame:
+        return self._loop_stack.push(frame)
+
+    def pop_loop(self) -> LoopFrame:
+        return self._loop_stack.pop()
+
+    def set_var(self, name: str, value: Any):
+        self._vars[name] = value
+
+    def get_var(self, name: str, default=None):
+        return self._vars.get(name, default)
+
+    def clear_var(self, name: str):
+        self._vars.pop(name, None)
 
     def __post_init__(self):
         # Ensure artifact directory exists
+        if self.artifact_dir is None:
+            self.artifact_dir = "./artifacts"
+            
         import pathlib
         pathlib.Path(self.artifact_dir).mkdir(parents=True, exist_ok=True)
 
@@ -108,3 +187,20 @@ class Context:
 
         return value
 
+    def expression_data(self) -> Dict[str, Any]:
+        data: Dict[str, Any] = {}
+        data.update(self._vars)
+        data["params"] = self.params
+        data["results"] = self.results
+        data["scratch"] = self.scratch
+        data["artifacts"] = self.artifacts
+        data["loop"] = self.loop
+        data["loops"] = list(self.loops)
+        return data
+
+    def env_data(self) -> Dict[str, str]:
+        import os
+
+        env_data = dict(os.environ)
+        env_data.update(self.env)
+        return env_data