proxytool 2.0.1__py3-none-any.whl

proxytool/settings.py

@@ -0,0 +1,66 @@
+"""Proxy settings, driven by LMW_* / LTP_* environment variables + CLI flags."""
+
+from __future__ import annotations
+
+import json
+import os
+
+
+def _model_map() -> dict[str, str]:
+    """Client-facing model id → real upstream model id.
+
+    Sources: LMW_MODEL_MAP (inline JSON object) or LMW_MODEL_MAP_FILE (path
+    to a JSON object). The bundled opencode configs use friendly ids
+    (`qwen-gguf`, `qwen-mlx`) that llama-server ignores but mlx_lm.server
+    resolves against HF — producing "Repository Not Found". With no mapping
+    configured, the alias passes through unchanged.
+    """
+    raw = os.environ.get("LTP_MODEL_MAP") or os.environ.get("LMW_MODEL_MAP") or ""
+    path = os.environ.get("LTP_MODEL_MAP_FILE") or os.environ.get("LMW_MODEL_MAP_FILE") or ""
+    data: dict[str, str] = {}
+    if path:
+        with open(path, encoding="utf-8") as f:
+            data.update(json.load(f))
+    elif raw:
+        data.update(json.loads(raw))
+    return data
+
+
+def _env(name: str, default: str) -> str:
+    """LTP_* wins over the legacy LMW_* spelling."""
+    return os.environ.get(f"LTP_{name}") or os.environ.get(f"LMW_{name}", default)
+
+
+class Settings:
+    def __init__(self) -> None:
+        self.host: str = _env("HOST", "127.0.0.1")
+        self.port: int = int(_env("PORT", "8180"))
+        self.upstream_url: str = _env("UPSTREAM_URL", "http://127.0.0.1:8181")
+        # Total seconds the middleware waits on an upstream request. Long
+        # model loads / cold-starts (llama-swap spins a backend on demand)
+        # need a large read window; SSE reads ride the read timeout too.
+        self.upstream_timeout: float = float(_env("UPSTREAM_TIMEOUT", "300"))
+        # Optional static bearer token sent as Authorization to the upstream
+        # (for llama-swap gateways / llama-server --api-key). Client auth
+        # headers are forwarded per-request separately in the conduit.
+        self.upstream_api_key: str = _env("UPSTREAM_API_KEY", "")
+        self.backend: str = _env("BACKEND", "gguf")
+        self.trace: bool = (_env("TRACE", "") == "1" or _env("TRACE_FILE", "") != "")
+        self.model_map: dict[str, str] = _model_map()
+        # LoopGuard thresholds (0 disables that escape entirely).
+        self.loop_nudge: int = int(_env("LOOP_NUDGE", "3") or 0)
+        self.loop_abort: int = int(_env("LOOP_ABORT", "6") or 0)
+
+    def upstream_url_changed_by_flag(self, flag_value: str | None) -> bool:
+        """True when a --upstream-url CLI flag (or its env) already set a URL."""
+        return bool(flag_value)
+
+
+def get_settings() -> Settings:
+    """Build Settings from env.
+
+    Deliberately does NOT touch logging configuration: the CLI (or an
+    explicit ``configure_logging`` call by the embedder) owns that, and
+    re-applying an env default here would clobber a CLI ``--log-level``.
+    """
+    return Settings()

proxytool/trace.py

@@ -0,0 +1,81 @@
+"""Trace: LMW_TRACE=1 dumps payload transit points to stderr for debugging.
+
+Optionally, an app-level logger can be injected (``attach_logger``); when
+present, trace payloads are also emitted at the DEBUG level through it so
+they show up in the configured logging pipeline.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import sys
+from typing import Any, TextIO
+
+_enabled = False
+_trace_file: TextIO | None = None
+_trace_log: Any = None  # set to a real logger via attach_logger()
+
+
+class _NoopLogger:
+    """Silent stand-in used until/independent of an injected logger."""
+
+    def debug(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+    def info(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+    def warning(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+    def error(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+
+def _noop_logger() -> _NoopLogger:
+    return _NoopLogger()
+
+
+def enable(enabled: bool) -> None:
+    global _enabled
+    _enabled = enabled
+
+
+def enabled() -> bool:
+    return _enabled or _trace_file is not None
+
+
+def attach_logger(logger: Any) -> None:
+    """Inject an app-level logger into the trace dumper.
+
+    When set, trace payloads are also emitted through the app logger at the
+    DEBUG level instead of only the raw stderr sink.
+    """
+    global _trace_log
+    _trace_log = logger
+
+
+# SIM115 is intentional: the trace sink lives for the process lifetime and is
+# cleaned up when the uvicorn process exits; no context manager applies.
+def _get_sink() -> TextIO:
+    global _trace_file
+    if _trace_file is None:
+        path = os.environ.get("LMW_TRACE_FILE")
+        sink: TextIO = (
+            open(path, "a", encoding="utf-8") if path else sys.stderr  # noqa: SIM115
+        )
+        _trace_file = sink
+    return _trace_file
+
+
+def log(stage: str, payload: object) -> None:
+    if not (enabled() or os.environ.get("LMW_TRACE_FILE")):
+        return
+    body = f"[{stage}]\n{json.dumps(payload, indent=2, default=str)}\n"
+    print(body, file=_get_sink(), flush=True)
+    if _trace_log is not None:
+        # Logging must never break payload forwarding.
+        with contextlib.suppress(Exception):
+            _trace_log.debug("trace %s: %s", stage, json.dumps(payload, default=str))