euron-code 0.1.0__py3-none-any.whl

euron_code/api.py

@@ -0,0 +1,364 @@
+"""HTTP client for the Euron Code gateway (CLI_AND_ACCESS_SPEC.md §3, §4).
+
+Only one model request is ever in flight per client: the gateway allows one generation per
+user by default and answers a second one with `user_queue_full`.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import platform
+import queue
+import socket
+import threading
+import time
+from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple
+
+import httpx
+
+from euron_code import __version__, config
+
+NO_PLUS_MESSAGE = (
+    "You don't have Euron Plus access. Euron Code is included with Euron Plus and Super 30. "
+    "Get Plus at https://euron.one/plus"
+)
+UPGRADE_URL = "https://euron.one/plus"
+ME_CACHE_TTL = 60.0
+
+AUTH_CODES = {"missing_api_key", "invalid_api_key", "api_key_revoked", "api_key_expired"}
+BUSY_CODES = {"queue_full", "user_queue_full", "queue_timeout", "no_capacity"}
+UNAVAILABLE_CODES = {"code_agent_disabled", "auth_unavailable"}
+
+
+# ---------------------------------------------------------------- errors
+
+class EuronError(Exception):
+    """Base error. `exit_code` is used by the CLI."""
+
+    exit_code = 1
+
+    def __init__(self, message: str, *, status: Optional[int] = None, code: Optional[str] = None,
+                 retry_after: Optional[float] = None):
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.retry_after = retry_after
+
+
+class AuthError(EuronError):
+    exit_code = 4
+
+
+class NotEntitledError(EuronError):
+    exit_code = 3
+
+
+class QuotaExceededError(EuronError):
+    exit_code = 5
+
+
+class RateLimitedError(EuronError):
+    pass
+
+
+class BusyError(EuronError):
+    pass
+
+
+class UnavailableError(EuronError):
+    pass
+
+
+class ContextTooLongError(EuronError):
+    pass
+
+
+class NetworkError(EuronError):
+    pass
+
+
+class MidStreamError(EuronError):
+    """The stream failed after output was already shown. Never retried automatically."""
+
+
+class Interrupted(Exception):
+    """The user pressed Esc / Ctrl-C during a request."""
+
+
+def _parse_retry_after(value: Optional[str]) -> Optional[float]:
+    if not value:
+        return None
+    try:
+        return max(0.0, float(value))
+    except ValueError:
+        return None
+
+
+def error_from_body(status: int, body: Any, retry_after: Optional[float] = None) -> EuronError:
+    """Map a gateway error body to a typed exception.
+
+    Accepts the OpenAI shape {error:{message,type,code}} and the dashboard shape {code,message}.
+    """
+    code = None
+    message = None
+    if isinstance(body, dict):
+        err = body.get("error") if isinstance(body.get("error"), dict) else body
+        code = err.get("code") or (body.get("error") if isinstance(body.get("error"), str) else None)
+        message = err.get("message")
+        if code is None and isinstance(err.get("status"), str):
+            code = err.get("status")
+    code = str(code) if code is not None else None
+    message = message or f"HTTP {status}"
+    kw = dict(status=status, code=code, retry_after=retry_after)
+    if code == "no_plus_access" or (status == 403 and code in (None, "forbidden")):
+        return NotEntitledError(NO_PLUS_MESSAGE, **kw)
+    if status == 401 or code in AUTH_CODES:
+        return AuthError(message, **kw)
+    if code == "daily_token_limit":
+        return QuotaExceededError(message, **kw)
+    if code == "rate_limit_exceeded":
+        return RateLimitedError(message, **kw)
+    if code in BUSY_CODES:
+        return BusyError(message, **kw)
+    if code in UNAVAILABLE_CODES:
+        return UnavailableError(message, **kw)
+    if status == 413 or code == "context_length_exceeded" or (
+        status == 400 and "context length" in message.lower()
+    ):
+        return ContextTooLongError(message, **kw)
+    if status == 503:
+        return BusyError(message, **kw)
+    if status == 429:
+        return RateLimitedError(message, **kw)
+    return EuronError(message, **kw)
+
+
+def _error_from_response(resp: httpx.Response) -> EuronError:
+    try:
+        body = resp.json()
+    except ValueError:
+        body = {"error": {"message": (resp.text or "")[:300] or f"HTTP {resp.status_code}"}}
+    return error_from_body(resp.status_code, body, _parse_retry_after(resp.headers.get("retry-after")))
+
+
+# ---------------------------------------------------------------- client
+
+def user_agent() -> str:
+    return f"euron-code/{__version__} ({platform.system()}; Python {platform.python_version()})"
+
+
+class Client:
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                 transport: Optional[httpx.BaseTransport] = None):
+        self.base_url = (base_url or config.base_url()).rstrip("/")
+        self.api_key = api_key
+        self.me_fetched_at = 0.0
+        self._lock = threading.Lock()  # one model request at a time
+        self._http = httpx.Client(
+            timeout=httpx.Timeout(connect=15.0, read=300.0, write=60.0, pool=15.0),
+            headers={"User-Agent": user_agent()},
+            transport=transport,
+            follow_redirects=False,
+        )
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _headers(self) -> Dict[str, str]:
+        if not self.api_key:
+            raise AuthError("You are not logged in. Run `euron login`.", status=401, code="missing_api_key")
+        return {"Authorization": f"Bearer {self.api_key}"}
+
+    def _request(self, method: str, path: str, *, auth: bool = True, **kw: Any) -> httpx.Response:
+        headers = kw.pop("headers", {})
+        if auth:
+            headers.update(self._headers())
+        try:
+            return self._http.request(method, self.base_url + path, headers=headers, **kw)
+        except httpx.TimeoutException as e:
+            raise NetworkError(f"Request to Euron Code timed out ({type(e).__name__}).") from None
+        except httpx.HTTPError as e:
+            raise NetworkError(f"Cannot reach Euron Code at {self.base_url}: {e}") from None
+
+    def _json(self, method: str, path: str, **kw: Any) -> Any:
+        resp = self._request(method, path, **kw)
+        if resp.status_code >= 400:
+            raise _error_from_response(resp)
+        try:
+            return resp.json()
+        except ValueError:
+            raise EuronError(f"Unexpected non-JSON reply from {path} (HTTP {resp.status_code}).")
+
+    # ------------------------------------------------------------ device flow (§3)
+
+    def device_start(self) -> Dict[str, Any]:
+        body = {
+            "clientName": "euron-code",
+            "clientVersion": __version__,
+            "hostname": socket.gethostname(),
+            "os": f"{platform.system()} {platform.release()}",
+        }
+        return self._json("POST", "/device/start", auth=False, json=body)
+
+    def device_poll(self, device_code: str) -> Tuple[str, Dict[str, Any]]:
+        """Return (status, body). status: pending | slow_down | denied | expired | approved."""
+        resp = self._request("POST", "/device/token", auth=False, json={"deviceCode": device_code})
+        try:
+            body = resp.json()
+        except ValueError:
+            body = {}
+        status = body.get("status") if isinstance(body, dict) else None
+        if resp.status_code == 200 and status == "approved":
+            return "approved", body
+        mapping = {428: "pending", 429: "slow_down", 403: "denied", 410: "expired"}
+        if status in ("pending", "slow_down", "denied", "expired"):
+            return status, body
+        if resp.status_code in mapping:
+            return mapping[resp.status_code], body
+        raise _error_from_response(resp)
+
+    # ------------------------------------------------------------ account (§4)
+
+    def _cache_path(self):
+        h = hashlib.sha256(((self.api_key or "") + "|" + self.base_url).encode()).hexdigest()[:20]
+        return config.euron_home() / "cache" / f"me-{h}.json"
+
+    def me(self, use_cache: bool = True) -> Dict[str, Any]:
+        path = self._cache_path()
+        if use_cache:
+            try:
+                with open(path, "r", encoding="utf-8") as f:
+                    cached = json.load(f)
+                if time.time() - float(cached.get("fetchedAt", 0)) < ME_CACHE_TTL:
+                    self.me_fetched_at = float(cached["fetchedAt"])
+                    return cached["data"]
+            except (OSError, ValueError, KeyError):
+                pass
+        data = self._json("GET", "/v1/me")
+        self.me_fetched_at = time.time()
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            with open(path, "w", encoding="utf-8") as f:
+                json.dump({"fetchedAt": time.time(), "data": data}, f)
+        except OSError:
+            pass
+        return data
+
+    def invalidate_me_cache(self) -> None:
+        try:
+            self._cache_path().unlink()
+        except OSError:
+            pass
+
+    def usage(self, days: int = 30) -> Dict[str, Any]:
+        return self._json("GET", "/v1/usage", params={"days": days})
+
+    def models(self) -> List[Dict[str, Any]]:
+        data = self._json("GET", "/v1/models")
+        return list(data.get("data") or []) if isinstance(data, dict) else []
+
+    # ------------------------------------------------------------ chat (§4)
+
+    def chat(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """Non-streaming completion (used for compaction summaries)."""
+        with self._lock:
+            body = dict(payload)
+            body["stream"] = False
+            return self._json("POST", "/v1/chat/completions", json=body)
+
+    def stream_chat(self, payload: Dict[str, Any], cancel: Optional[threading.Event] = None,
+                    on_wait: Optional[Callable[[], None]] = None) -> Iterator[Dict[str, Any]]:
+        """Yield parsed SSE chunks (dicts). Runs the socket read in a worker thread so the
+        caller can interrupt (Esc / Ctrl-C) even while the request waits in the queue.
+
+        Raises a typed EuronError for HTTP errors and for SSE `data: {"error":...}` frames.
+        """
+        if not self._lock.acquire(blocking=False):
+            raise EuronError("Internal error: a model request is already running.")
+        q: "queue.Queue[Tuple[str, Any]]" = queue.Queue()
+        holder: Dict[str, Any] = {}
+        body = dict(payload)
+        body["stream"] = True
+        body.setdefault("stream_options", {"include_usage": True})
+
+        def worker() -> None:
+            try:
+                with self._http.stream("POST", self.base_url + "/v1/chat/completions",
+                                       headers=self._headers(), json=body) as resp:
+                    holder["resp"] = resp
+                    if resp.status_code >= 400:
+                        resp.read()
+                        q.put(("error", _error_from_response(resp)))
+                        return
+                    for line in resp.iter_lines():
+                        if cancel is not None and cancel.is_set():
+                            return
+                        if not line or line.startswith(":"):
+                            q.put(("tick", None))  # keep-alive comment: ignore
+                            continue
+                        if not line.startswith("data:"):
+                            continue
+                        data = line[5:].strip()
+                        if data == "[DONE]":
+                            q.put(("done", None))
+                            return
+                        try:
+                            obj = json.loads(data)
+                        except ValueError:
+                            continue
+                        if isinstance(obj, dict) and obj.get("error"):
+                            q.put(("error", error_from_body(int(obj["error"].get("status") or 500)
+                                                            if isinstance(obj["error"], dict) else 500, obj)))
+                            return
+                        q.put(("chunk", obj))
+                    q.put(("done", None))
+            except httpx.TimeoutException:
+                q.put(("error", NetworkError("The connection to Euron Code timed out.")))
+            except httpx.HTTPError as e:
+                q.put(("error", NetworkError(f"Connection to Euron Code failed: {e}")))
+            except Exception as e:  # pragma: no cover - defensive
+                q.put(("error", EuronError(f"Unexpected error while streaming: {e}")))
+
+        t = threading.Thread(target=worker, name="euron-stream", daemon=True)
+        t.start()
+        try:
+            while True:
+                if cancel is not None and cancel.is_set():
+                    raise Interrupted()
+                try:
+                    kind, val = q.get(timeout=0.1)
+                except queue.Empty:
+                    if on_wait:
+                        on_wait()
+                    continue
+                if kind == "chunk":
+                    yield val
+                elif kind == "tick":
+                    if on_wait:
+                        on_wait()
+                elif kind == "error":
+                    raise val
+                elif kind == "done":
+                    return
+        finally:
+            resp = holder.get("resp")
+            if resp is not None and t.is_alive():
+                try:
+                    resp.close()
+                except Exception:
+                    pass
+            t.join(timeout=2.0)
+            self._lock.release()
+
+
+def plan_label(access: Dict[str, Any]) -> str:
+    parts = []
+    if access.get("plus"):
+        parts.append("Euron Plus")
+    if access.get("super30"):
+        parts.append("Super 30")
+    if access.get("pilot"):
+        parts.append("Pilot")
+    return " + ".join(parts) if parts else ("Entitled" if access.get("entitled") else "No plan")

euron_code/auth.py

@@ -0,0 +1,115 @@
+"""`euron login` (device flow, spec §3), `logout`, `whoami`."""
+
+from __future__ import annotations
+
+import os
+import time
+import webbrowser
+from typing import Callable, Dict, Optional
+
+from euron_code import api, credentials
+from euron_code.api import EuronError, NetworkError, NotEntitledError
+
+
+def _open_browser(url: str) -> bool:
+    if os.environ.get("EURON_NO_BROWSER"):
+        return False
+    try:
+        return bool(webbrowser.open(url, new=2))
+    except Exception:
+        return False
+
+
+def device_login(client: api.Client, ui, *, open_browser: bool = True,
+                 sleep: Callable[[float], None] = time.sleep,
+                 clock: Callable[[], float] = time.monotonic) -> credentials.Credential:
+    start = client.device_start()
+    code = start.get("userCode", "")
+    url = start.get("verificationUriComplete") or start.get("verificationUri") or ""
+    interval = float(start.get("interval") or 5)
+    expires = float(start.get("expiresIn") or 600)
+    device_code = start["deviceCode"]
+
+    ui.info("")
+    ui.info(f"To sign in, open this page and confirm the code [bold]{code}[/bold]:")
+    ui.info(f"  {url}")
+    opened = open_browser and _open_browser(url)
+    if opened:
+        ui.dim("  (opened in your browser)")
+    else:
+        ui.dim("  (copy the link into a browser where you are logged in to euron.one)")
+    ui.info("")
+
+    deadline = clock() + expires
+    net_failures = 0
+    with ui.console.status("Waiting for you to approve in the browser... (Ctrl-C to cancel)") \
+            if ui.console.is_terminal else _null():
+        while True:
+            if clock() > deadline:
+                raise EuronError("The login code expired. Run `euron login` again.")
+            sleep(interval)
+            try:
+                status, body = client.device_poll(device_code)
+            except NetworkError:
+                net_failures += 1
+                if net_failures > 5:
+                    raise
+                continue
+            net_failures = 0
+            if status == "pending":
+                continue
+            if status == "slow_down":
+                interval += 5  # RFC 8628 3.5
+                continue
+            if status == "denied":
+                raise EuronError("Login was denied in the browser.")
+            if status == "expired":
+                raise EuronError("The login code expired. Run `euron login` again.")
+            if status == "approved":
+                key = body.get("apiKey")
+                if not key:
+                    raise EuronError("The server approved the login but sent no key. Try again.")
+                cred = credentials.Credential(api_key=key, base_url=client.base_url, user=body.get("user") or {})
+                return cred
+
+
+class _null:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+
+def login(ui, base_url: Optional[str] = None, open_browser: bool = True) -> Dict:
+    """Full login: device flow, save the key, then check entitlement via /v1/me.
+    Raises NotEntitledError (exit 3) when the account has no Plus / Super 30."""
+    c = api.Client(base_url=base_url)
+    try:
+        cred = device_login(c, ui, open_browser=open_browser)
+    finally:
+        c.close()
+    store = credentials.save(cred)
+    authed = api.Client(api_key=cred.api_key, base_url=cred.base_url)
+    try:
+        me = authed.me(use_cache=False)
+    finally:
+        authed.close()
+    user = me.get("user") or cred.user or {}
+    ui.info(f"[green]Logged in[/green] as {user.get('name') or ''} <{user.get('email') or ''}>"
+            f"  (key {credentials.mask_key(cred.api_key)}, stored in {store})")
+    if not (me.get("access") or {}).get("entitled"):
+        raise NotEntitledError(api.NO_PLUS_MESSAGE, status=403, code="no_plus_access")
+    return me
+
+
+def logout(ui, base_url: Optional[str] = None) -> None:
+    url = base_url or api.config.base_url()
+    cred = credentials.load(url)
+    if cred:
+        api.Client(api_key=cred.api_key, base_url=url).invalidate_me_cache()
+    if credentials.delete(url):
+        ui.info("Logged out. The key was removed from this computer.")
+        ui.dim("To revoke it on the server too, delete it at https://euron.one/code-agent (API keys).")
+    else:
+        ui.info("You were not logged in.")