llmt-cli 0.2.0__py3-none-any.whl

llmt/__init__.py

@@ -0,0 +1,7 @@
+"""llmt — LLM Torrents command-line client.
+
+Find, download (over BitTorrent + webseeds) and SHA-256-verify LLM models
+from the public LLM Torrents catalog API.
+"""
+
+__version__ = "0.2.0"

llmt/api.py

@@ -0,0 +1,138 @@
+"""HTTP client for the FROZEN WP-8.1 public API.
+
+Envelope contract:
+    success : {"data": ..., "meta"?: ...}
+    error   : {"error": {"code", "message", "details"?}}
+
+Base URL: default https://llmtorrents.com/api, overridable via the
+``LLMT_API_BASE`` env var or ``--api-base``. An optional bearer token
+(``LLMT_API_KEY`` / ``--api-key``) only raises rate limits (reads are public).
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+import requests
+
+from .errors import (
+    ApiError,
+    NotFoundError,
+    RateLimitedError,
+    TimeoutErrorLlmt,
+)
+
+DEFAULT_API_BASE = "https://llmtorrents.com/api"
+DEFAULT_TIMEOUT = 30
+
+
+def resolve_base(explicit: Optional[str] = None) -> str:
+    base = explicit or os.environ.get("LLMT_API_BASE") or DEFAULT_API_BASE
+    return base.rstrip("/")
+
+
+def resolve_key(explicit: Optional[str] = None) -> Optional[str]:
+    return explicit or os.environ.get("LLMT_API_KEY") or None
+
+
+class ApiClient:
+    """Thin, dependency-light wrapper over the catalog's JSON API."""
+
+    def __init__(self, base: Optional[str] = None, key: Optional[str] = None,
+                 timeout: int = DEFAULT_TIMEOUT,
+                 session: Optional[requests.Session] = None):
+        self.base = resolve_base(base)
+        self.key = resolve_key(key)
+        self.timeout = timeout
+        self.session = session or requests.Session()
+
+    # ---- low-level ------------------------------------------------------
+    def _headers(self) -> dict[str, str]:
+        h = {"Accept": "application/json", "User-Agent": "llmt-cli"}
+        if self.key:
+            h["Authorization"] = f"Bearer {self.key}"
+        return h
+
+    def _get(self, path: str, params: Optional[dict] = None) -> dict[str, Any]:
+        url = f"{self.base}/{path.lstrip('/')}"
+        try:
+            resp = self.session.get(
+                url, params=params, headers=self._headers(), timeout=self.timeout
+            )
+        except requests.Timeout as exc:
+            raise TimeoutErrorLlmt(
+                f"API request timed out after {self.timeout}s: {url}"
+            ) from exc
+        except requests.RequestException as exc:
+            raise ApiError(f"API request failed: {exc}") from exc
+        return self._handle(resp, url)
+
+    def _handle(self, resp: "requests.Response", url: str) -> dict[str, Any]:
+        # Try to decode an error envelope regardless of status.
+        payload: Any = None
+        try:
+            payload = resp.json()
+        except ValueError:
+            payload = None
+
+        err = payload.get("error") if isinstance(payload, dict) else None
+        code = err.get("code") if isinstance(err, dict) else None
+        message = err.get("message") if isinstance(err, dict) else None
+        details = err.get("details") if isinstance(err, dict) else None
+
+        if resp.status_code == 200 and isinstance(payload, dict) and "error" not in payload:
+            return payload
+
+        if resp.status_code == 429:
+            ra = resp.headers.get("Retry-After")
+            retry_after = None
+            if ra is not None:
+                try:
+                    retry_after = int(ra)
+                except ValueError:
+                    retry_after = None
+            raise RateLimitedError(
+                message or "Rate limited by the API.",
+                retry_after=retry_after, code=code or "rate_limited",
+                status=429, details=details,
+            )
+        if resp.status_code == 404:
+            raise NotFoundError(
+                message or "Not found.", code=code or "not_found",
+                status=404, details=details,
+            )
+        if resp.status_code == 403:
+            raise ApiError(
+                message or "Forbidden (the resource may be license-gated).",
+                code=code or "forbidden", status=403, details=details,
+            )
+        # Any other non-200, or a 200 that is actually an error envelope.
+        raise ApiError(
+            message or f"Unexpected API response (HTTP {resp.status_code}).",
+            code=code, status=resp.status_code, details=details,
+        )
+
+    # ---- endpoints ------------------------------------------------------
+    def list_models(self, q: Optional[str] = None, fit: Optional[str] = None,
+                    per_page: int = 24, sort: Optional[str] = None,
+                    extra: Optional[dict] = None) -> dict[str, Any]:
+        params: dict[str, Any] = {"per_page": per_page}
+        if q:
+            params["q"] = q
+        if fit:
+            params["fit"] = fit
+        if sort:
+            params["sort"] = sort
+        if extra:
+            params.update(extra)
+        return self._get("/models", params=params)
+
+    def get_model(self, slug: str) -> dict[str, Any]:
+        return self._get(f"/models/{slug}")
+
+    def get_manifest(self, info_hash: str) -> dict[str, Any]:
+        return self._get(f"/manifests/{info_hash}")
+
+    def get_fit(self, params: dict) -> dict[str, Any]:
+        return self._get("/fit", params=params)