abstractgateway 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

abstractgateway/config.py

@@ -56,12 +56,14 @@ class GatewayHostConfig:
 
     data_dir: Path
     flows_dir: Path
+    store_backend: str = "file"  # file|sqlite
+    db_path: Optional[Path] = None
 
     runner_enabled: bool = True
     poll_interval_s: float = 0.25
     command_batch_limit: int = 200
     tick_max_steps: int = 100
-    tick_workers: int = 2
+    tick_workers: int = 4
     run_scan_limit: int = 200
 
     @staticmethod
@@ -69,13 +71,21 @@ class GatewayHostConfig:
         # NOTE: We intentionally use ABSTRACTGATEWAY_* as the canonical namespace.
         # For a transition period, we accept legacy ABSTRACTFLOW_* names as fallbacks.
         data_dir_raw = _env("ABSTRACTGATEWAY_DATA_DIR", "ABSTRACTFLOW_RUNTIME_DIR") or "./runtime"
-        flows_dir_raw = _env("ABSTRACTGATEWAY_FLOWS_DIR", "ABSTRACTFLOW_FLOWS_DIR") or "./flows"
+        flows_dir_raw = (
+            _env("ABSTRACTGATEWAY_FLOWS_DIR")
+            or _env("ABSTRACTFRAMEWORK_WORKFLOWS_DIR")
+            or _env("ABSTRACTFLOW_FLOWS_DIR")
+            or "./flows"
+        )
+
+        store_backend = str(_env("ABSTRACTGATEWAY_STORE_BACKEND") or "file").strip().lower() or "file"
+        db_path_raw = _env("ABSTRACTGATEWAY_DB_PATH")
 
         enabled_raw = _env("ABSTRACTGATEWAY_RUNNER", "ABSTRACTFLOW_GATEWAY_RUNNER") or "1"
         runner_enabled = _as_bool(enabled_raw, True)
 
         poll_s = _as_float(_env("ABSTRACTGATEWAY_POLL_S", "ABSTRACTFLOW_GATEWAY_POLL_S"), 0.25)
-        tick_workers = _as_int(_env("ABSTRACTGATEWAY_TICK_WORKERS", "ABSTRACTFLOW_GATEWAY_TICK_WORKERS"), 2)
+        tick_workers = _as_int(_env("ABSTRACTGATEWAY_TICK_WORKERS", "ABSTRACTFLOW_GATEWAY_TICK_WORKERS"), 4)
         tick_steps = _as_int(_env("ABSTRACTGATEWAY_TICK_MAX_STEPS", "ABSTRACTFLOW_GATEWAY_TICK_MAX_STEPS"), 100)
         batch = _as_int(_env("ABSTRACTGATEWAY_COMMAND_BATCH_LIMIT", "ABSTRACTFLOW_GATEWAY_COMMAND_BATCH_LIMIT"), 200)
         scan = _as_int(_env("ABSTRACTGATEWAY_RUN_SCAN_LIMIT", "ABSTRACTFLOW_GATEWAY_RUN_SCAN_LIMIT"), 200)
@@ -83,6 +93,8 @@ class GatewayHostConfig:
         return GatewayHostConfig(
             data_dir=Path(data_dir_raw).expanduser().resolve(),
             flows_dir=Path(flows_dir_raw).expanduser().resolve(),
+            store_backend=store_backend,
+            db_path=Path(db_path_raw).expanduser().resolve() if db_path_raw else None,
             runner_enabled=bool(runner_enabled),
             poll_interval_s=float(poll_s),
             command_batch_limit=max(1, int(batch)),
@@ -90,5 +102,3 @@ class GatewayHostConfig:
             tick_workers=max(1, int(tick_workers)),
             run_scan_limit=max(1, int(scan)),
         )
-
-

abstractgateway/embeddings_config.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Tuple
+
+
+def _load_json_file(path: Path) -> Dict[str, Any]:
+    try:
+        raw = path.read_text(encoding="utf-8")
+        data = json.loads(raw)
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _save_json_file(path: Path, data: Dict[str, Any]) -> None:
+    try:
+        path.write_text(json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8")
+    except Exception:
+        return
+
+
+def resolve_embedding_config(*, base_dir: Path) -> Tuple[str, str]:
+    """Resolve the gateway-wide embedding provider/model.
+
+    Contract:
+    - Stable within a single gateway instance (singleton embedding space).
+    - Persisted under the gateway data dir so restarts keep the same embedding space by default.
+    - Env vars can override (and will re-write the persisted value).
+    """
+    provider_env = os.getenv("ABSTRACTGATEWAY_EMBEDDING_PROVIDER") or os.getenv("ABSTRACTFLOW_EMBEDDING_PROVIDER")
+    model_env = os.getenv("ABSTRACTGATEWAY_EMBEDDING_MODEL") or os.getenv("ABSTRACTFLOW_EMBEDDING_MODEL")
+
+    cfg_path = Path(base_dir) / "gateway_embeddings.json"
+    cfg = _load_json_file(cfg_path) if cfg_path.exists() else {}
+
+    provider = str(provider_env or cfg.get("provider") or "lmstudio").strip().lower()
+    model = str(model_env or cfg.get("model") or "text-embedding-nomic-embed-text-v1.5@q6_k").strip()
+
+    # Persist for stability across restart (best-effort).
+    _save_json_file(cfg_path, {"provider": provider, "model": model})
+    return provider, model
+

abstractgateway/host_metrics.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import datetime
+import os
+import re
+import shutil
+import subprocess
+import sys
+import threading
+import time
+from typing import Any, Dict, List, Optional
+
+
+_CACHE_LOCK = threading.Lock()
+_CACHE_AT_S: float = 0.0
+_CACHE_VALUE: Optional[Dict[str, Any]] = None
+
+
+def _utc_now_iso() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+
+def _parse_nvidia_smi_csv(text: str) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    for raw_line in str(text or "").splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 3:
+            continue
+        try:
+            idx = int(parts[0])
+        except Exception:
+            continue
+        name = parts[1]
+        try:
+            util = float(parts[2])
+        except Exception:
+            util = None
+        out.append({"index": idx, "name": name, "utilization_gpu_pct": util})
+    return out
+
+
+def _read_nvidia_smi_gpu_metrics(*, timeout_s: float = 1.0) -> Dict[str, Any]:
+    exe = shutil.which("nvidia-smi")
+    if not exe:
+        return {"supported": False, "reason": "nvidia-smi not available"}
+
+    cmd = [
+        exe,
+        "--query-gpu=index,name,utilization.gpu",
+        "--format=csv,noheader,nounits",
+    ]
+
+    try:
+        p = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=float(timeout_s),
+            check=False,
+        )
+    except Exception as e:
+        return {"supported": False, "reason": f"nvidia-smi failed: {e}"}
+
+    if p.returncode != 0:
+        stderr = (p.stderr or "").strip()
+        detail = f" (exit={p.returncode})"
+        if stderr:
+            detail = f"{detail}: {stderr}"
+        return {"supported": False, "reason": f"nvidia-smi error{detail}"}
+
+    gpus = _parse_nvidia_smi_csv(p.stdout or "")
+    vals = [g.get("utilization_gpu_pct") for g in gpus if isinstance(g.get("utilization_gpu_pct"), (int, float))]
+    utilization: Optional[float] = None
+    if vals:
+        utilization = float(sum(vals) / len(vals))
+
+    return {
+        "supported": True,
+        "source": "nvidia-smi",
+        "utilization_gpu_pct": utilization,
+        "gpus": gpus,
+    }
+
+
+_IOREG_ENTRY_HEADER_RE = re.compile(r"^\+\-o\s+([^\s<]+)\s+<class\s+([^,>]+)")
+_IOREG_MODEL_RE = re.compile(r'"model"\s*=\s*"([^"]+)"')
+_IOREG_PERF_STATS_RE = re.compile(r'"PerformanceStatistics"\s*=\s*\{(.*?)\}', re.DOTALL)
+_IOREG_KV_RE = re.compile(r'"([^"]+)"\s*=\s*([^,}]+)')
+
+
+def _coerce_number(value: str) -> Optional[float]:
+    s = str(value or "").strip()
+    if not s:
+        return None
+    if s.startswith("<") or s.startswith("("):
+        return None
+    try:
+        if "." in s:
+            return float(s)
+        return float(int(s))
+    except Exception:
+        return None
+
+
+def _parse_ioreg_ioaccelerator_output(text: str) -> List[Dict[str, Any]]:
+    """Parse `ioreg -r -c IOAccelerator -l` output into GPU utilization records (macOS).
+
+    macOS exposes GPU activity in IORegistry `PerformanceStatistics` for IOAccelerator entries.
+    Example keys:
+    - "Device Utilization %"
+    - "Renderer Utilization %"
+    - "Tiler Utilization %"
+    """
+
+    entries: list[str] = []
+    cur: list[str] = []
+    for line in str(text or "").splitlines():
+        if line.startswith("+-o "):
+            if cur:
+                entries.append("\n".join(cur))
+            cur = [line]
+        else:
+            if cur:
+                cur.append(line)
+    if cur:
+        entries.append("\n".join(cur))
+
+    gpus: List[Dict[str, Any]] = []
+    for entry in entries:
+        header = entry.splitlines()[0] if entry else ""
+        m = _IOREG_ENTRY_HEADER_RE.match(header)
+        if m:
+            obj_name = m.group(1)
+            cls_name = m.group(2)
+        else:
+            obj_name = ""
+            cls_name = ""
+
+        model_m = _IOREG_MODEL_RE.search(entry)
+        model = model_m.group(1) if model_m else ""
+
+        perf_m = _IOREG_PERF_STATS_RE.search(entry)
+        if not perf_m:
+            continue
+        body = perf_m.group(1)
+
+        stats: Dict[str, Any] = {}
+        for k, v_raw in _IOREG_KV_RE.findall(body):
+            num = _coerce_number(v_raw)
+            stats[k] = num if num is not None else str(v_raw).strip()
+
+        # Filter to entries that look like GPU perf stats.
+        if not any(k in stats for k in ("Device Utilization %", "Renderer Utilization %", "Tiler Utilization %")):
+            continue
+
+        dev = stats.get("Device Utilization %")
+        rend = stats.get("Renderer Utilization %")
+        tiler = stats.get("Tiler Utilization %")
+
+        gpus.append(
+            {
+                "index": len(gpus),
+                "name": (model or obj_name or cls_name or "GPU").strip() or "GPU",
+                "utilization_gpu_pct": dev if isinstance(dev, (int, float)) else None,
+                "renderer_utilization_pct": rend if isinstance(rend, (int, float)) else None,
+                "tiler_utilization_pct": tiler if isinstance(tiler, (int, float)) else None,
+            }
+        )
+
+    return gpus
+
+
+def _read_ioreg_gpu_metrics(*, timeout_s: float = 1.0) -> Dict[str, Any]:
+    exe = shutil.which("ioreg") or "/usr/sbin/ioreg"
+    if not exe:
+        return {"supported": False, "reason": "ioreg not available"}
+
+    cmd = [exe, "-r", "-c", "IOAccelerator", "-l"]
+    try:
+        p = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=float(timeout_s),
+            check=False,
+        )
+    except Exception as e:
+        return {"supported": False, "reason": f"ioreg failed: {e}"}
+
+    if p.returncode != 0:
+        stderr = (p.stderr or "").strip()
+        detail = f" (exit={p.returncode})"
+        if stderr:
+            detail = f"{detail}: {stderr}"
+        return {"supported": False, "reason": f"ioreg error{detail}"}
+
+    gpus = _parse_ioreg_ioaccelerator_output(p.stdout or "")
+    if not gpus:
+        return {"supported": False, "reason": "IOAccelerator performance stats not found"}
+
+    vals = [g.get("utilization_gpu_pct") for g in gpus if isinstance(g.get("utilization_gpu_pct"), (int, float))]
+    utilization: Optional[float] = None
+    if vals:
+        utilization = float(sum(vals) / len(vals))
+
+    return {
+        "supported": True,
+        "source": "ioreg",
+        "utilization_gpu_pct": utilization,
+        "gpus": gpus,
+    }
+
+
+def _read_host_gpu_metrics_best_effort(*, timeout_s: float = 1.0) -> Dict[str, Any]:
+    provider_raw = str(os.getenv("ABSTRACTGATEWAY_GPU_METRICS_PROVIDER", "auto") or "auto").strip().lower()
+    if provider_raw in {"0", "off", "false", "none", "disabled"}:
+        return {"supported": False, "reason": "disabled"}
+
+    if provider_raw not in {"auto", "nvidia-smi", "nvidia", "ioreg", "macos"}:
+        return {"supported": False, "reason": f"unknown provider '{provider_raw}'"}
+
+    if provider_raw == "auto":
+        providers = ["ioreg", "nvidia-smi"] if sys.platform == "darwin" else ["nvidia-smi", "ioreg"]
+    elif provider_raw in {"nvidia", "nvidia-smi"}:
+        providers = ["nvidia-smi"]
+    else:
+        providers = ["ioreg"]
+
+    reasons: list[str] = []
+    for p in providers:
+        if p == "ioreg":
+            payload = _read_ioreg_gpu_metrics(timeout_s=timeout_s)
+        else:
+            payload = _read_nvidia_smi_gpu_metrics(timeout_s=timeout_s)
+
+        if payload.get("supported") is True:
+            return payload
+        r = payload.get("reason")
+        if isinstance(r, str) and r.strip():
+            reasons.append(r.strip())
+
+    return {"supported": False, "reason": "; ".join(reasons) if reasons else "unsupported"}
+
+
+def get_host_gpu_metrics(*, cache_ttl_s: float = 0.5) -> Dict[str, Any]:
+    """Return best-effort host GPU utilization metrics.
+
+    This is intentionally dependency-light:
+    - macOS: reads IORegistry IOAccelerator PerformanceStatistics via `ioreg`
+    - NVIDIA: reads utilization via `nvidia-smi`
+    """
+
+    global _CACHE_AT_S, _CACHE_VALUE
+
+    ttl = max(0.0, float(cache_ttl_s))
+    now = time.time()
+
+    if ttl > 0:
+        with _CACHE_LOCK:
+            if _CACHE_VALUE is not None and (now - _CACHE_AT_S) <= ttl:
+                return dict(_CACHE_VALUE)
+
+    payload = _read_host_gpu_metrics_best_effort(timeout_s=1.0)
+    out: Dict[str, Any] = {"ts": _utc_now_iso(), **payload}
+
+    if ttl > 0:
+        with _CACHE_LOCK:
+            _CACHE_AT_S = now
+            _CACHE_VALUE = dict(out)
+
+    return out