refactor: add centralized method to get auth token (#61)

Author: TimilsinaBimal

app/api/endpoints/catalogs.py

@@ -85,17 +85,12 @@ async def get_catalog(type: str, id: str, response: Response, token: str):
         user_settings = UserSettings(**settings_dict) if settings_dict else get_default_settings()
         language = user_settings.language if user_settings else "en-US"
 
-        # Create services with credentials (prefer fresh login with email/password)
-        if credentials.get("password") and credentials.get("email"):
-            stremio_service = StremioService(
-                username=credentials.get("email", ""), password=credentials.get("password", "")
-            )
-            try:
-                await stremio_service._login_for_auth_key()
-            except Exception:
-                stremio_service = StremioService(auth_key=credentials.get("authKey"))
-        else:
-            stremio_service = StremioService(auth_key=credentials.get("authKey"))
+        # Create a single service; get_auth_key() will validate/refresh as needed
+        stremio_service = StremioService(
+            username=credentials.get("email", ""),
+            password=credentials.get("password", ""),
+            auth_key=credentials.get("authKey"),
+        )
         # Fetch library once per request and reuse across recommendation paths
         library_items = await stremio_service.get_library_items()
         recommendation_service = RecommendationService(

app/api/endpoints/manifest.py

@@ -96,17 +96,12 @@ async def _manifest_handler(response: Response, token: str):
 
     base_manifest = get_base_manifest(user_settings)
 
-    # Build dynamic catalogs using the already-fetched credentials
-    # Build Stremio service with fresh auth when possible
-    if creds.get("password") and creds.get("email"):
-        stremio_service = StremioService(username=creds.get("email", ""), password=creds.get("password", ""))
-        try:
-            await stremio_service._login_for_auth_key()
-        except Exception:
-            # fallback to stored authKey if login fails
-            stremio_service = StremioService(auth_key=creds.get("authKey"))
-    else:
-        stremio_service = StremioService(auth_key=creds.get("authKey"))
+    # Build dynamic catalogs using a single service; get_auth_key() handles validation/refresh
+    stremio_service = StremioService(
+        username=creds.get("email", ""),
+        password=creds.get("password", ""),
+        auth_key=creds.get("authKey"),
+    )
     try:
         fetched_catalogs = await build_dynamic_catalogs(
             stremio_service,

app/api/endpoints/tokens.py

@@ -89,10 +89,9 @@ async def create_token(payload: TokenRequest, request: Request) -> TokenResponse
     if email and password:
         stremio_service = StremioService(username=email, password=password)
         try:
-            # Always get a fresh key
-            fresh_key = await stremio_service._login_for_auth_key()
-            stremio_auth_key = fresh_key
-            user_info = await stremio_service.get_user_info()
+            # Centralized key retrieval (validates/refreshes)
+            stremio_auth_key = await stremio_service.get_auth_key()
+            user_info = await stremio_service.get_user_info(stremio_auth_key)
             user_id = user_info["user_id"]
             resolved_email = user_info.get("email", email)
         except Exception as e:
@@ -102,7 +101,7 @@ async def create_token(payload: TokenRequest, request: Request) -> TokenResponse
     else:
         stremio_service = StremioService(auth_key=stremio_auth_key)
         try:
-            user_info = await stremio_service.get_user_info()
+            user_info = await stremio_service.get_user_info(stremio_auth_key)
             user_id = user_info["user_id"]
             resolved_email = user_info.get("email", "")
         except Exception as e:
@@ -147,7 +146,12 @@ async def create_token(payload: TokenRequest, request: Request) -> TokenResponse
     # 6. Store user data
     try:
         token = await token_store.store_user_data(user_id, payload_to_store)
-        logger.info(f"[{redact_token(token)}] Account {'created' if is_new_account else 'updated'} for user {user_id}")
+        logger.info(
+            "[%s] Account %s for user %s",
+            redact_token(token),
+            "created" if is_new_account else "updated",
+            user_id,
+        )
     except RuntimeError as exc:
         # Surface a clear message when secure storage fails
         if "PASSWORD_ENCRYPT_FAILED" in str(exc):
@@ -175,20 +179,23 @@ async def get_stremio_user_data(payload: TokenRequest) -> tuple[str, str]:
     if email and password:
         svc = StremioService(username=email, password=password)
         try:
-            await svc._login_for_auth_key()
-            user_info = await svc.get_user_info()
+            auth_key = await svc.get_auth_key()
+            user_info = await svc.get_user_info(auth_key)
             return user_info["user_id"], user_info.get("email", email)
         except Exception as e:
             logger.error(f"Stremio identity check failed (email/password): {e}")
-            raise HTTPException(status_code=400, detail="Failed to verify Stremio identity with email/password.")
+            raise HTTPException(
+                status_code=400,
+                detail="Failed to verify Stremio identity with email/password.",
+            )
         finally:
             await svc.close()
     elif auth_key:
         if auth_key.startswith('"') and auth_key.endswith('"'):
             auth_key = auth_key[1:-1].strip()
         svc = StremioService(auth_key=auth_key)
         try:
-            user_info = await svc.get_user_info()
+            user_info = await svc.get_user_info(auth_key)
             return user_info["user_id"], user_info.get("email", "")
         except Exception as e:
             logger.error(f"Stremio identity check failed: {e}")

app/core/version.py

@@ -1 +1 @@
-__version__ = "1.3.0"
+__version__ = "1.3.1"

app/services/stremio_service.py

@@ -121,9 +121,43 @@ async def _login_for_auth_key(self) -> str:
             raise
 
     async def get_auth_key(self) -> str:
-        """Return the cached auth key."""
+        """Return a valid auth key; refresh transparently if expired and credentials exist."""
+        # If we have a key, validate it via GetUser
+        if self._auth_key:
+            try:
+                await self.get_user_info(self._auth_key)
+                return self._auth_key
+            except Exception:
+                # fall through to attempt refresh
+                pass
+
+        # Refresh using username/password if available
+        if self.username and self.password:
+            fresh_key = await self._login_for_auth_key()
+
+            # Persist refreshed key back to Redis, best-effort
+            try:
+                from app.services.token_store import token_store  # lazy import to avoid cycles
+
+                try:
+                    info = await self.get_user_info(fresh_key)
+                    uid = info.get("user_id")
+                except Exception:
+                    uid = None
+                if uid:
+                    existing = await token_store.get_user_data(uid)
+                    if existing:
+                        updated = existing.copy()
+                        updated["authKey"] = fresh_key
+                        await token_store.store_user_data(uid, updated)
+            except Exception:
+                pass
+
+            return fresh_key
+
+        # No credentials to refresh; if we still have no key, error
         if not self._auth_key:
-            raise ValueError("Stremio auth key is missing.")
+            raise ValueError("Stremio auth key is missing and cannot be refreshed.")
         return self._auth_key
 
     async def is_loved(self, auth_key: str, imdb_id: str, media_type: str) -> tuple[bool, bool]:
@@ -176,15 +210,16 @@ async def get_liked_items(self, auth_token: str, media_type: str) -> list[str]:
             logger.warning(f"Failed to fetch liked items: {e}")
             return []
 
-    async def get_user_info(self) -> dict[str, str]:
-        """Fetch user ID and email using the auth key."""
-        if not self._auth_key:
+    async def get_user_info(self, auth_key: str | None = None) -> dict[str, str]:
+        """Fetch user ID and email using the provided auth key (or self._auth_key)."""
+        key = auth_key or self._auth_key
+        if not key:
             raise ValueError("Stremio auth key is missing.")
 
         url = f"{self.base_url}/api/getUser"
         payload = {
             "type": "GetUser",
-            "authKey": self._auth_key,
+            "authKey": key,
         }
 
         try:
@@ -212,7 +247,8 @@ async def get_user_info(self) -> dict[str, str]:
 
     async def get_user_email(self) -> str:
         """Fetch user email using the auth key."""
-        user_info = await self.get_user_info()
+        auth_key = await self.get_auth_key()
+        user_info = await self.get_user_info(auth_key)
         return user_info.get("email", "")
 
     async def get_library_items(self) -> dict[str, list[dict]]:
@@ -221,10 +257,6 @@ async def get_library_items(self) -> dict[str, list[dict]]:
         Returns a dict with 'watched' and 'loved' keys.
         """
 
-        if not self._auth_key:
-            logger.warning("Stremio auth key not configured")
-            return {"watched": [], "loved": []}
-
         try:
             # Get auth token
             auth_key = await self.get_auth_key()
@@ -321,7 +353,11 @@ def _sort_key(x: dict):
 
                 added_items.append(item)
 
-            logger.info(f"Found {len(added_items)} added (unwatched) and {len(removed_items)} removed library items")
+            logger.info(
+                "Found %s added (unwatched) and %s removed library items",
+                len(added_items),
+                len(removed_items),
+            )
             # Prepare result
             result = {
                 "watched": watched_items,
@@ -413,7 +449,12 @@ async def _post_with_retries(self, client: httpx.AsyncClient, url: str, json: di
                     attempts += 1
                     backoff = (2 ** (attempts - 1)) + random.uniform(0, 0.25)
                     logger.warning(
-                        f"Stremio POST {url} failed with {status}; retry {attempts}/{max_tries} in" f" {backoff:.2f}s"
+                        "Stremio POST %s failed with %s; retry %s/%s in %.2fs",
+                        url,
+                        status,
+                        attempts,
+                        max_tries,
+                        backoff,
                     )
                     await asyncio.sleep(backoff)
                     last_exc = e
@@ -422,7 +463,14 @@ async def _post_with_retries(self, client: httpx.AsyncClient, url: str, json: di
             except httpx.RequestError as e:
                 attempts += 1
                 backoff = (2 ** (attempts - 1)) + random.uniform(0, 0.25)
-                logger.warning(f"Stremio POST {url} request error: {e}; retry {attempts}/{max_tries} in {backoff:.2f}s")
+                logger.warning(
+                    "Stremio POST %s request error: %s; retry %s/%s in %.2fs",
+                    url,
+                    e,
+                    attempts,
+                    max_tries,
+                    backoff,
+                )
                 await asyncio.sleep(backoff)
                 last_exc = e
                 continue
@@ -446,7 +494,12 @@ async def _get_with_retries(
                     attempts += 1
                     backoff = (2 ** (attempts - 1)) + random.uniform(0, 0.25)
                     logger.warning(
-                        f"Stremio GET {url} failed with {status}; retry {attempts}/{max_tries} in" f" {backoff:.2f}s"
+                        "Stremio GET %s failed with %s; retry %s/%s in %.2fs",
+                        url,
+                        status,
+                        attempts,
+                        max_tries,
+                        backoff,
                     )
                     await asyncio.sleep(backoff)
                     last_exc = e
@@ -455,7 +508,14 @@ async def _get_with_retries(
             except httpx.RequestError as e:
                 attempts += 1
                 backoff = (2 ** (attempts - 1)) + random.uniform(0, 0.25)
-                logger.warning(f"Stremio GET {url} request error: {e}; retry {attempts}/{max_tries} in {backoff:.2f}s")
+                logger.warning(
+                    "Stremio GET %s request error: %s; retry %s/%s in %.2fs",
+                    url,
+                    e,
+                    attempts,
+                    max_tries,
+                    backoff,
+                )
                 await asyncio.sleep(backoff)
                 last_exc = e
                 continue