riffsdk 0.1.0__py3-none-any.whl

riffsdk/_internal/auth.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import http
+import os
+from collections.abc import Generator
+from time import time
+from typing import ClassVar
+
+import httpx
+
+FIREBASE_API_KEY = "AIzaSyAdgR9BGfQrV2fzndXZLZYgiRtpydlq8ug"
+
+
+class _StaticTokenAuth(httpx.Auth):
+    """Bearer auth with a fixed token string."""
+
+    def __init__(self, token: str) -> None:
+        self._token = token
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        request.headers["Authorization"] = f"Bearer {self._token}"
+        yield request
+
+
+class RiffAuth(httpx.Auth):
+    """Firebase-based auth with automatic token refresh.
+
+    Uses a long-lived refresh token to obtain short-lived ID tokens
+    from Firebase, refreshing proactively before expiry.
+    """
+
+    requires_response_body = True
+    refresh_interval = 15 * 60
+    _default: ClassVar[RiffAuth | None] = None
+
+    def __init__(
+        self,
+        refresh_token: str,
+        *,
+        firebase_api_key: str = FIREBASE_API_KEY,
+    ) -> None:
+        if not refresh_token:
+            raise ValueError("refresh_token must be non-empty")
+        self._firebase_api_key = firebase_api_key
+        self._refresh_token = refresh_token
+        self._access_token = ""
+        self._last_refresh = time() - 2 * self.refresh_interval
+
+    @classmethod
+    def default(cls) -> RiffAuth:
+        if cls._default is None:
+            cls._default = cls.from_env()
+        return cls._default
+
+    @classmethod
+    def from_env(
+        cls,
+        *,
+        env_var: str = "RIFF_TOKEN",
+        firebase_api_key: str = FIREBASE_API_KEY,
+    ) -> RiffAuth:
+        token = os.environ.get(env_var)
+        if token is None:
+            raise RuntimeError(f"Missing environment variable: {env_var}")
+        return cls(token, firebase_api_key=firebase_api_key)
+
+    def _token_expires_soon(self) -> bool:
+        return time() - self._last_refresh > self.refresh_interval
+
+    def _build_refresh_request(self) -> httpx.Request:
+        return httpx.Request(
+            method="POST",
+            url=f"https://securetoken.googleapis.com/v1/token?key={self._firebase_api_key}",
+            data={
+                "grant_type": "refresh_token",
+                "refresh_token": self._refresh_token,
+            },
+        )
+
+    def _handle_refresh_response(self, response: httpx.Response) -> None:
+        if response.status_code == http.HTTPStatus.OK:
+            self._access_token = response.json()["id_token"]
+            self._last_refresh = time()
+        else:
+            raise RuntimeError("Token refresh failed")
+
+    def auth_flow(
+        self, request: httpx.Request
+    ) -> Generator[httpx.Request, httpx.Response, None]:
+        if self._token_expires_soon():
+            refresh_response = yield self._build_refresh_request()
+            self._handle_refresh_response(refresh_response)
+
+        request.headers["Authorization"] = f"Bearer {self._access_token}"
+        yield request

riffsdk/_internal/config.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import os
+
+
+def default_base_url() -> str:
+    project_id = os.environ.get("RIFF_PROJECT_ID")
+    if project_id is None:
+        raise RuntimeError("Missing environment variable: RIFF_PROJECT_ID")
+    return f"https://api.riff.new/_projects/{project_id}/apis/riff-api"

riffsdk/storage/__init__.py

@@ -0,0 +1,59 @@
+from riffsdk._internal.auth import RiffAuth
+from riffsdk.storage._async_client import AsyncLease, AsyncStorageClient
+from riffsdk.storage._client import Lease, StorageClient
+from riffsdk.storage._models import (
+    DownloadResult,
+    ListPage,
+    ObjectMeta,
+    Scope,
+    UploadPart,
+    UploadResult,
+    account_scope,
+    project_scope,
+    session_scope,
+)
+from riffsdk.storage._streaming import StorageReader, StorageWriter
+from riffsdk.storage._upload import AsyncResumableUpload, ResumableUpload
+from riffsdk.storage.exceptions import (
+    AlreadyExistsError,
+    AuthorisationError,
+    LeaseConflictError,
+    ObjectNotFoundError,
+    PartMismatchError,
+    QuotaExceededError,
+    StorageError,
+    StorageTransportError,
+    UploadNotFoundError,
+    VersionConflictError,
+)
+
+__all__ = [
+    "AsyncLease",
+    "AsyncResumableUpload",
+    "RiffAuth",
+    "AsyncStorageClient",
+    "DownloadResult",
+    "Lease",
+    "ResumableUpload",
+    "Scope",
+    "StorageClient",
+    "ObjectMeta",
+    "UploadPart",
+    "ListPage",
+    "UploadResult",
+    "StorageReader",
+    "StorageWriter",
+    "StorageError",
+    "AuthorisationError",
+    "ObjectNotFoundError",
+    "VersionConflictError",
+    "AlreadyExistsError",
+    "LeaseConflictError",
+    "UploadNotFoundError",
+    "QuotaExceededError",
+    "PartMismatchError",
+    "StorageTransportError",
+    "account_scope",
+    "project_scope",
+    "session_scope",
+]