pyoco 0.3.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

pyoco/server/api.py

@@ -1,37 +1,43 @@
-from fastapi import FastAPI, HTTPException
-from typing import List, Optional
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import PlainTextResponse
+from typing import List, Optional, Dict, Any
 from .store import StateStore
 from .models import (
-    RunSubmitRequest, RunResponse, 
+    RunSubmitRequest, RunResponse,
     WorkerPollRequest, WorkerPollResponse,
     WorkerHeartbeatRequest, WorkerHeartbeatResponse
 )
-from ..core.models import RunContext, RunStatus
+from ..core.models import RunStatus
+from .metrics import metrics, metrics_content_type
 
 app = FastAPI(title="Pyoco Kanban Server")
 store = StateStore()
 
 @app.post("/runs", response_model=RunResponse)
-def submit_run(req: RunSubmitRequest):
+async def submit_run(req: RunSubmitRequest):
     run_ctx = store.create_run(req.flow_name, req.params)
     return RunResponse(run_id=run_ctx.run_id, status=run_ctx.status)
 
-@app.get("/runs", response_model=List[RunContext])
-def list_runs(status: Optional[RunStatus] = None):
-    runs = store.list_runs()
-    if status:
-        runs = [r for r in runs if r.status == status]
-    return runs
+@app.get("/runs")
+async def list_runs(
+    status: Optional[str] = None,
+    flow: Optional[str] = None,
+    limit: Optional[int] = Query(default=None, ge=1, le=200),
+):
+    status_enum = _parse_status(status)
+    limit_value = limit if isinstance(limit, int) else None
+    runs = store.list_runs(status=status_enum, flow=flow, limit=limit_value)
+    return [store.export_run(r) for r in runs]
 
-@app.get("/runs/{run_id}", response_model=RunContext)
-def get_run(run_id: str):
+@app.get("/runs/{run_id}")
+async def get_run(run_id: str):
     run = store.get_run(run_id)
     if not run:
         raise HTTPException(status_code=404, detail="Run not found")
-    return run
+    return store.export_run(run)
 
 @app.post("/runs/{run_id}/cancel")
-def cancel_run(run_id: str):
+async def cancel_run(run_id: str):
     run = store.get_run(run_id)
     if not run:
         raise HTTPException(status_code=404, detail="Run not found")
@@ -39,7 +45,7 @@ def cancel_run(run_id: str):
     return {"status": "CANCELLING"}
 
 @app.post("/workers/poll", response_model=WorkerPollResponse)
-def poll_work(req: WorkerPollRequest):
+async def poll_work(req: WorkerPollRequest):
     # In v0.3.0, we ignore worker_id and tags for simplicity
     run = store.dequeue()
     if run:
@@ -58,14 +64,49 @@ def poll_work(req: WorkerPollRequest):
     return WorkerPollResponse()
 
 @app.post("/runs/{run_id}/heartbeat", response_model=WorkerHeartbeatResponse)
-def heartbeat(run_id: str, req: WorkerHeartbeatRequest):
+async def heartbeat(run_id: str, req: WorkerHeartbeatRequest):
     run = store.get_run(run_id)
     if not run:
         raise HTTPException(status_code=404, detail="Run not found")
         
-    store.update_run(run_id, status=req.run_status, task_states=req.task_states)
+    store.update_run(
+        run_id,
+        status=req.run_status,
+        task_states=req.task_states,
+        task_records=req.task_records,
+        logs=req.logs
+    )
     
     # Check if cancellation was requested
     cancel_requested = (run.status == RunStatus.CANCELLING)
     
     return WorkerHeartbeatResponse(cancel_requested=cancel_requested)
+
+@app.get("/runs/{run_id}/logs")
+async def get_logs(run_id: str, task: Optional[str] = None, tail: Optional[int] = None):
+    run = store.get_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="Run not found")
+    logs = run.logs
+    if task:
+        logs = [entry for entry in logs if entry["task"] == task]
+    if tail:
+        logs = logs[-tail:]
+    return {"run_status": run.status, "logs": logs}
+
+
+@app.get("/metrics")
+async def prometheus_metrics():
+    payload = metrics.render_latest()
+    return PlainTextResponse(payload, media_type=metrics_content_type())
+
+
+def _parse_status(value: Optional[str]) -> Optional[RunStatus]:
+    if not value:
+        return None
+    if isinstance(value, RunStatus):
+        return value
+    try:
+        return RunStatus(value)
+    except ValueError:
+        raise HTTPException(status_code=400, detail=f"Invalid status '{value}'")

pyoco/server/metrics.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from prometheus_client import (
+    CollectorRegistry,
+    CONTENT_TYPE_LATEST,
+    Counter,
+    Gauge,
+    Histogram,
+    generate_latest,
+)
+
+from ..core.models import RunStatus
+
+
+_DEFAULT_BUCKETS = (
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1.0,
+    2.5,
+    5.0,
+    10.0,
+    30.0,
+    60.0,
+)
+
+
+class MetricsSink:
+    """
+    Small wrapper that owns a CollectorRegistry so tests can reset easily.
+    """
+
+    def __init__(self) -> None:
+        self.registry = CollectorRegistry()
+        self._init_metrics()
+
+    def _init_metrics(self) -> None:
+        self.runs_total = Counter(
+            "pyoco_runs_total",
+            "Total runs observed by status transitions.",
+            ["status"],
+            registry=self.registry,
+        )
+        self.runs_in_progress = Gauge(
+            "pyoco_runs_in_progress",
+            "Number of runs currently executing (RUNNING).",
+            registry=self.registry,
+        )
+        self.task_duration = Histogram(
+            "pyoco_task_duration_seconds",
+            "Observed task durations.",
+            ["task"],
+            buckets=_DEFAULT_BUCKETS,
+            registry=self.registry,
+        )
+        self.run_duration = Histogram(
+            "pyoco_run_duration_seconds",
+            "Observed end-to-end run durations.",
+            ["flow"],
+            buckets=_DEFAULT_BUCKETS,
+            registry=self.registry,
+        )
+
+    def reset(self) -> None:
+        self.__init__()
+
+    def record_status_transition(
+        self,
+        previous: Optional[RunStatus],
+        new_status: RunStatus,
+    ) -> None:
+        status_value = new_status.value if hasattr(new_status, "value") else str(new_status)
+        self.runs_total.labels(status=status_value).inc()
+
+        prev_value = previous.value if hasattr(previous, "value") else previous
+        if status_value == RunStatus.RUNNING.value:
+            if prev_value != RunStatus.RUNNING.value:
+                self.runs_in_progress.inc()
+        elif prev_value == RunStatus.RUNNING.value:
+            self.runs_in_progress.dec()
+
+    def record_task_duration(self, task_name: str, duration_ms: Optional[float]) -> None:
+        if duration_ms is None:
+            return
+        if duration_ms < 0:
+            return
+        self.task_duration.labels(task=task_name).observe(duration_ms / 1000.0)
+
+    def record_run_duration(
+        self,
+        flow_name: str,
+        start_time: Optional[float],
+        end_time: Optional[float],
+    ) -> None:
+        if start_time is None or end_time is None:
+            return
+        duration = end_time - start_time
+        if duration < 0:
+            return
+        self.run_duration.labels(flow=flow_name).observe(duration)
+
+    def render_latest(self) -> bytes:
+        return generate_latest(self.registry)
+
+
+metrics = MetricsSink()
+
+
+def metrics_content_type() -> str:
+    return CONTENT_TYPE_LATEST

pyoco/server/models.py

@@ -22,6 +22,8 @@ class WorkerPollResponse(BaseModel):
 
 class WorkerHeartbeatRequest(BaseModel):
     task_states: Dict[str, TaskState]
+    task_records: Dict[str, Any] = {}
+    logs: List[Dict[str, Any]] = []
     run_status: RunStatus
 
 class WorkerHeartbeatResponse(BaseModel):

pyoco/server/store.py

@@ -1,38 +1,63 @@
 import uuid
 import time
-from typing import Dict, List, Optional
-from ..core.models import RunContext, RunStatus
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from ..core.models import RunContext, RunStatus, TaskState
+from .metrics import metrics
+from .webhook import webhook_notifier
+
+MAX_RUN_HISTORY = int(os.getenv("PYOCO_MAX_RUN_HISTORY", "50"))
+RUN_ARCHIVE_DIR = Path(os.getenv("PYOCO_RUN_ARCHIVE_DIR", "artifacts/runs"))
+MAX_LOG_BYTES_PER_TASK = int(os.getenv("PYOCO_MAX_LOG_BYTES", str(1024 * 1024)))
 
 class StateStore:
     def __init__(self):
         self.runs: Dict[str, RunContext] = {}
         self.queue: List[str] = []
+        self.history: List[str] = []
+        self.max_runs = MAX_RUN_HISTORY
+        self.archive_dir = RUN_ARCHIVE_DIR
+        self.log_limit_bytes = MAX_LOG_BYTES_PER_TASK
+        self.metrics = metrics
+        self.webhook = webhook_notifier
         
     def create_run(self, flow_name: str, params: Dict) -> RunContext:
         run_id = str(uuid.uuid4())
         run_ctx = RunContext(
             run_id=run_id,
+            flow_name=flow_name,
+            params=params or {},
             status=RunStatus.PENDING,
             start_time=time.time()
         )
-        # Store extra metadata if needed (flow_name, params)
-        # For now, RunContext doesn't have flow_name/params fields in core.models.
-        # We might need to extend RunContext or store them separately.
-        # Let's attach them dynamically for now or assume the worker knows.
-        # Actually, the worker needs flow_name and params to run.
-        # We should store them in the store alongside the context.
-        run_ctx.flow_name = flow_name
-        run_ctx.params = params
         
         self.runs[run_id] = run_ctx
         self.queue.append(run_id)
+        self.history.append(run_id)
+        self._enforce_retention()
+        self.metrics.record_status_transition(None, run_ctx.status)
         return run_ctx
 
     def get_run(self, run_id: str) -> Optional[RunContext]:
         return self.runs.get(run_id)
 
-    def list_runs(self) -> List[RunContext]:
-        return list(self.runs.values())
+    def list_runs(
+        self,
+        status: Optional[RunStatus] = None,
+        flow: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> List[RunContext]:
+        runs = list(self.runs.values())
+        if status:
+            runs = [r for r in runs if r.status == status]
+        if flow:
+            runs = [r for r in runs if r.flow_name == flow]
+        runs.sort(key=lambda r: r.start_time or 0, reverse=True)
+        if limit:
+            runs = runs[:limit]
+        return runs
 
     def dequeue(self, tags: List[str] = None) -> Optional[RunContext]:
         # Simple FIFO queue for now. Tags ignored in v0.3.0 MVP.
@@ -53,11 +78,12 @@ class StateStore:
                 
         return None
 
-    def update_run(self, run_id: str, status: RunStatus = None, task_states: Dict = None):
+    def update_run(self, run_id: str, status: RunStatus = None, task_states: Dict = None, task_records: Dict = None, logs: List[Dict[str, Any]] = None):
         run = self.runs.get(run_id)
         if not run:
             return
-            
+        previous_status = run.status
+
         if status:
             # State transition check
             # If server has CANCELLING, ignore RUNNING from worker
@@ -70,13 +96,124 @@ class StateStore:
                 if not run.end_time:
                     run.end_time = time.time()
                     
+        if run.status != previous_status:
+            self.metrics.record_status_transition(previous_status, run.status)
+
         if task_states:
-            run.tasks.update(task_states)
+            for name, state in task_states.items():
+                run.tasks[name] = TaskState(state) if isinstance(state, str) else state
+        if task_records:
+            for name, record in task_records.items():
+                info = run.ensure_task_record(name)
+                state_val = record.get("state")
+                if state_val:
+                    info.state = TaskState(state_val) if isinstance(state_val, str) else state_val
+                info.started_at = record.get("started_at", info.started_at)
+                info.ended_at = record.get("ended_at", info.ended_at)
+                info.duration_ms = record.get("duration_ms", info.duration_ms)
+                info.error = record.get("error", info.error)
+                info.traceback = record.get("traceback", info.traceback)
+                info.inputs = record.get("inputs", info.inputs)
+                info.output = record.get("output", info.output)
+                info.artifacts = record.get("artifacts", info.artifacts)
+                self._record_task_metrics(run, name, info)
+        if logs:
+            for entry in logs:
+                task_name = entry.get("task") or "unknown"
+                text = entry.get("text", "")
+                encoded_len = len(text.encode("utf-8"))
+                current = run.log_bytes.get(task_name, 0)
+                if current >= self.log_limit_bytes:
+                    continue
+                if current + encoded_len > self.log_limit_bytes:
+                    allowed = max(self.log_limit_bytes - current, 0)
+                    truncated_text = text[:allowed] + "\n[log truncated]"
+                    entry = dict(entry)
+                    entry["text"] = truncated_text
+                    run.log_bytes[task_name] = self.log_limit_bytes
+                else:
+                    run.log_bytes[task_name] = current + encoded_len
+                run.logs.append(entry)
+        if status in [RunStatus.COMPLETED, RunStatus.FAILED, RunStatus.CANCELLED]:
+            self._enforce_retention()
+        if run.end_time and not run.metrics_run_observed:
+            self.metrics.record_run_duration(run.flow_name, run.start_time, run.end_time)
+            run.metrics_run_observed = True
+        if run.status in [RunStatus.COMPLETED, RunStatus.FAILED, RunStatus.CANCELLED]:
+            if run.webhook_notified_status != run.status.value:
+                if self.webhook.notify_run(run):
+                    run.webhook_notified_status = run.status.value
 
     def cancel_run(self, run_id: str):
         run = self.runs.get(run_id)
         if not run:
             return
-            
+        previous = run.status
         if run.status in [RunStatus.PENDING, RunStatus.RUNNING]:
             run.status = RunStatus.CANCELLING
+        if run.status != previous:
+            self.metrics.record_status_transition(previous, run.status)
+
+    def export_run(self, run: RunContext) -> Dict[str, Any]:
+        return {
+            "run_id": run.run_id,
+            "flow_name": run.flow_name,
+            "params": run.params,
+            "status": run.status.value if hasattr(run.status, "value") else run.status,
+            "start_time": run.start_time,
+            "end_time": run.end_time,
+            "tasks": {name: state.value if hasattr(state, "value") else state for name, state in run.tasks.items()},
+            "task_records": run.serialize_task_records(),
+            "logs": run.logs,
+            "metadata": run.metadata,
+            "run_duration_ms": self._run_duration_ms(run),
+            "task_summary": self._build_task_summary(run),
+        }
+
+    def _enforce_retention(self):
+        removable_ids = [rid for rid in self.history if rid in self.runs]
+        while len(self.runs) > self.max_runs and removable_ids:
+            run_id = removable_ids.pop(0)
+            run = self.runs.get(run_id)
+            if not run:
+                continue
+            if run.status not in [RunStatus.COMPLETED, RunStatus.FAILED, RunStatus.CANCELLED]:
+                self.history.append(run_id)
+                continue
+            self._spill_run(run)
+            self.runs.pop(run_id, None)
+            if run_id in self.queue:
+                self.queue.remove(run_id)
+        self.history = [rid for rid in self.history if rid in self.runs]
+
+    def _spill_run(self, run: RunContext):
+        try:
+            self.archive_dir.mkdir(parents=True, exist_ok=True)
+            path = self.archive_dir / f"{run.run_id}.json"
+            with path.open("w", encoding="utf-8") as fp:
+                json.dump(self.export_run(run), fp, indent=2)
+        except Exception:
+            pass
+
+    def _record_task_metrics(self, run: RunContext, task_name: str, record):
+        if task_name in run.metrics_recorded_tasks:
+            return
+        if record.duration_ms is None or record.ended_at is None:
+            return
+        self.metrics.record_task_duration(task_name, record.duration_ms)
+        run.metrics_recorded_tasks.add(task_name)
+
+    def _run_duration_ms(self, run: RunContext) -> Optional[float]:
+        if run.start_time and run.end_time:
+            return (run.end_time - run.start_time) * 1000.0
+        return None
+
+    def _build_task_summary(self, run: RunContext) -> Dict[str, Any]:
+        summary: Dict[str, Any] = {}
+        for name, record in run.task_records.items():
+            summary[name] = {
+                "state": record.state.value if hasattr(record.state, "value") else record.state,
+                "duration_ms": record.duration_ms,
+                "ended_at": record.ended_at,
+            }
+        return summary

pyoco/server/webhook.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+from typing import Any, Callable, Dict, Optional
+
+import httpx
+
+from ..core.models import RunContext, RunStatus
+
+
+class WebhookNotifier:
+    def __init__(self) -> None:
+        self.url: Optional[str] = None
+        self.timeout: float = 3.0
+        self.retries: int = 1
+        self.secret: Optional[str] = None
+        self.extra_headers: Dict[str, str] = {}
+        self._sender: Optional[Callable[[str, Dict[str, Any], Dict[str, str], float], None]] = None
+        self.last_error: Optional[str] = None
+        self.load_from_env()
+
+    def load_from_env(self) -> None:
+        self.url = os.getenv("PYOCO_WEBHOOK_URL") or None
+        self.timeout = float(os.getenv("PYOCO_WEBHOOK_TIMEOUT", "3.0"))
+        self.retries = int(os.getenv("PYOCO_WEBHOOK_RETRIES", "1"))
+        self.secret = os.getenv("PYOCO_WEBHOOK_SECRET") or None
+        self.extra_headers = {}
+        self.last_error = None
+        self._sender = None
+
+    def configure(
+        self,
+        *,
+        url: Optional[str] = None,
+        timeout: Optional[float] = None,
+        retries: Optional[int] = None,
+        secret: Optional[str] = None,
+        headers: Optional[Dict[str, str]] = None,
+        sender: Optional[Callable[[str, Dict[str, Any], Dict[str, str], float], None]] = None,
+    ) -> None:
+        if url is not None:
+            self.url = url
+        if timeout is not None:
+            self.timeout = timeout
+        if retries is not None:
+            self.retries = max(1, retries)
+        if secret is not None:
+            self.secret = secret
+        if headers is not None:
+            self.extra_headers = dict(headers)
+        if sender is not None:
+            self._sender = sender
+        self.last_error = None
+
+    def notify_run(self, run: RunContext) -> bool:
+        if not self.url:
+            return False
+        payload = self._build_payload(run)
+        sender = self._sender or self._http_sender
+        headers = {"Content-Type": "application/json", **self.extra_headers}
+        if self.secret:
+            headers.setdefault("X-Pyoco-Token", self.secret)
+
+        last_exc: Optional[Exception] = None
+        for attempt in range(self.retries):
+            try:
+                sender(self.url, payload, headers, self.timeout)
+                self.last_error = None
+                return True
+            except Exception as exc:  # pragma: no cover - retries captured via tests
+                last_exc = exc
+                time.sleep(min(0.5, 0.1 * (attempt + 1)))
+        if last_exc:
+            self.last_error = str(last_exc)
+        return False
+
+    def _http_sender(
+        self,
+        url: str,
+        payload: Dict[str, Any],
+        headers: Dict[str, str],
+        timeout: float,
+    ) -> None:
+        httpx.post(url, json=payload, headers=headers, timeout=timeout)
+
+    def _build_payload(self, run: RunContext) -> Dict[str, Any]:
+        duration_ms = None
+        if run.start_time and run.end_time:
+            duration_ms = (run.end_time - run.start_time) * 1000.0
+        return {
+            "event": f"run.{run.status.value.lower()}",
+            "run_id": run.run_id,
+            "flow_name": run.flow_name,
+            "status": run.status.value if isinstance(run.status, RunStatus) else run.status,
+            "started_at": run.start_time,
+            "ended_at": run.end_time,
+            "duration_ms": duration_ms,
+            "tasks": run.serialize_task_records(),
+            "metadata": run.metadata,
+        }
+
+    def reset(self) -> None:
+        self.load_from_env()
+
+
+webhook_notifier = WebhookNotifier()

pyoco/socketless_reset.py

@@ -0,0 +1,7 @@
+from pyoco.server.api import store
+
+
+def reset_store():
+    store.runs.clear()
+    store.queue.clear()
+    store.history.clear()

pyoco/worker/runner.py

@@ -21,11 +21,7 @@ class RemoteTraceBackend(TraceBackend):
     def _send_heartbeat(self, force=False):
         now = time.time()
         if force or (now - self.last_heartbeat > self.heartbeat_interval):
-            cancel = self.client.heartbeat(
-                self.run_ctx.run_id,
-                self.run_ctx.tasks,
-                self.run_ctx.status
-            )
+            cancel = self.client.heartbeat(self.run_ctx)
             if cancel and self.run_ctx.status not in [RunStatus.CANCELLING, RunStatus.CANCELLED]:
                 print(f"🛑 Cancellation requested from server for run {self.run_ctx.run_id}")
                 self.run_ctx.status = RunStatus.CANCELLING
@@ -162,10 +158,9 @@ class Worker:
             engine.run(flow, params=params, run_context=run_ctx)
             print(f"✅ Job {run_id} completed: {run_ctx.status}")
             # Send final heartbeat
-            self.client.heartbeat(run_id, run_ctx.tasks, run_ctx.status)
+            self.client.heartbeat(run_ctx)
         except Exception as e:
             print(f"💥 Job {run_id} failed: {e}")
             # Heartbeat one last time
             run_ctx.status = RunStatus.FAILED
-            self.client.heartbeat(run_id, run_ctx.tasks, run_ctx.status)
-
+            self.client.heartbeat(run_ctx)

{pyoco-0.3.0.dist-info → pyoco-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyoco
-Version: 0.3.0
+Version: 0.5.1
 Summary: A workflow engine with sugar syntax
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -8,6 +8,7 @@ Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.20.0
 Requires-Dist: httpx>=0.24.0
+Requires-Dist: prometheus-client>=0.20.0
 
 # 🐇 Pyoco
 
@@ -132,6 +133,20 @@ Or via CLI flag:
 pyoco run --non-cute ...
 ```
 
+## 🔭 Observability Bridge (v0.5)
+
+- `/metrics` exposes Prometheus counters (`pyoco_runs_total`, `pyoco_runs_in_progress`) and histograms (`pyoco_task_duration_seconds`, `pyoco_run_duration_seconds`). Point Grafana/Prometheus at it to watch pipelines without opening sockets.
+- `/runs` now accepts `status`, `flow`, `limit` query params; `/runs/{id}/logs?tail=100` fetches only the latest snippets for dashboards.
+- Webhook notifications fire when runs COMPLETE/FAIL—configure via `PYOCO_WEBHOOK_*` env vars and forward to Slack or your alerting stack.
+- Import `docs/grafana_pyoco_cute.json` for a lavender/orange starter dashboard (3 panels: in-progress count, completion trend, per-flow latency).
+- 詳細な手順は [docs/observability.md](docs/observability.md) を参照してください。
+
+## 🧩 Plug-ins
+
+Need to share domain-specific tasks? Publish an entry point under `pyoco.tasks` and pyoco will auto-load it. In v0.5.1 we recommend **Task subclasses first** (callables still work with warnings). See [docs/plugins.md](docs/plugins.md) for examples, quickstart, and `pyoco plugins list` / `pyoco plugins lint`.
+
+**Big data note:** pass handles, not copies. For large tensors/images, stash paths or handles in `ctx.artifacts`/`ctx.scratch` and let downstream tasks materialize only when needed. For lazy pipelines (e.g., DataPipe), log the pipeline when you actually iterate (typically the training task) instead of materializing upstream.
+
 ## 📚 Documentation
 
 - [Tutorials](docs/tutorial/index.md)

pyoco-0.5.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+pyoco/__init__.py,sha256=E2pgDGvGRSVon7dSqIM4UD55LgVpf4jiZZA-70kOcuw,409
+pyoco/client.py,sha256=Y95NmMsOKTJ9AZJEg_OzHamC_w32YWmSVS653mpqHVQ,3141
+pyoco/socketless_reset.py,sha256=KsAF4I23_Kbhy9fIWFARzV5QaIOQqbl0U0yPb8a34sM,129
+pyoco/cli/entry.py,sha256=zPIG0Gx-cFO8Cf1Z3wD3Ifz_2sHaryHZ6mCRri2WEqE,93
+pyoco/cli/main.py,sha256=LbhgTgRw9Tr_04hiYLqLP64jdnE1RA8B9Rasetgc_MM,18557
+pyoco/core/base_task.py,sha256=z7hOFntAPv4yCADapS-fhtLe5eWqaO8k3T1r05YEEUE,2106
+pyoco/core/context.py,sha256=TeCUriOmg7qZB3nMRu8HPdPshMW6pMVx48xZLY6a-A4,6524
+pyoco/core/engine.py,sha256=iX2Id8ryFt-xeZgraqnF3uqkI6ubiZt5NBNYWX6Qv1s,24166
+pyoco/core/exceptions.py,sha256=G82KY8PCnAhp3IDDIG8--Uh3EfVa192zei3l6ihfShI,565
+pyoco/core/models.py,sha256=8faYURF43-7IebqzTIorHxpCeC4TZfoXWjGyPNaWhyI,10501
+pyoco/discovery/loader.py,sha256=L9Wb2i-d1Hv3EiTFUvuR2mrv7Fc9vt5Bv9ZRuRqAzSg,6132
+pyoco/discovery/plugins.py,sha256=r1KY-OwWXSSe6arVOdfK72pGaI3tpumucg9cXEXA-Z0,4873
+pyoco/dsl/__init__.py,sha256=xWdb60pSRL8lNFk4GHF3EJ4hon0uiWqpv264g6-4gdg,45
+pyoco/dsl/expressions.py,sha256=BtEIxPSf3BU-wPNEicIqX_TVZ4fAnlWGrzrrfc6pU1g,4875
+pyoco/dsl/nodes.py,sha256=qDiIEsAJHnD8dpuOd-Rpy6OORCW6KDW_BdYiA2BKu18,1041
+pyoco/dsl/syntax.py,sha256=kYP5uGbwxmkSd_zeSksax8iWm_7UlRW5JxE9_DoSqbk,8638
+pyoco/dsl/validator.py,sha256=HXjcc-GzjH72YByaNxAg_7YOZsVsFDFnUaenVwd5PbY,3576
+pyoco/schemas/config.py,sha256=KkGZK3GxTHoIHEGb4f4k8GE2W-aBN4iPzmc_HrwuROU,1735
+pyoco/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyoco/server/api.py,sha256=vu2ieDZgHbi8cysO2rS-lcxqWiSQprIcqRn6GkwTtKo,3890
+pyoco/server/metrics.py,sha256=92sHZKka_yBNBGlHZgRIteywx97aoTa-MnXh3UJ0HJY,2952
+pyoco/server/models.py,sha256=ir5AuvyXQigmaynA7bS_0RNJcJo2VtpJl0GjRZrj2rU,786
+pyoco/server/store.py,sha256=ITYAV1QlPWDnceywqjjJZW9E0CyocFlPmqqfjcoM-wA,9133
+pyoco/server/webhook.py,sha256=fBSLWTDN7sIWSK0AUVuiCSdVVBFV_AyP-XEKOcdMXmQ,3643
+pyoco/trace/backend.py,sha256=a1css94_lhO4SGSPHZ1f59HJqFQtZ5Sjx09Kw7v5bsk,617
+pyoco/trace/console.py,sha256=I-BcF405OGLWoacJWeke8vTT9M5JxSBpJL-NazVyxb4,1742
+pyoco/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyoco/worker/client.py,sha256=862KccXRtfG7zd9ZSLqrpVSV6ev8zeuEHHdtAfLghiM,1557
+pyoco/worker/runner.py,sha256=hyKn5NbuIuF-109CnQbYc8laKbWmwe9ChaLrNUtsVIg,6367
+pyoco-0.5.1.dist-info/METADATA,sha256=JLUsGfujXl71AvCSuKDc52v2FjSxlWcIocGyCCzHnrU,5642
+pyoco-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyoco-0.5.1.dist-info/top_level.txt,sha256=2JRVocfaWRbX1VJ3zq1c5wQaOK6fMARS6ptVFWyvRF4,6
+pyoco-0.5.1.dist-info/RECORD,,