refactor: remove unused TMDB addon configurations and improve metadata fetching logic; update logging and catalog generation methods

Author: TimilsinaBimal

app/core/app.py

@@ -1,4 +1,3 @@
-import logging
 import os
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -14,18 +13,17 @@
 
 from .config import settings
 
+# class InterceptHandler(logging.Handler):
+#     def emit(self, record):
+#         try:
+#             level = logger.level(record.levelname).name
+#         except Exception:
+#             level = record.levelno
 
-class InterceptHandler(logging.Handler):
-    def emit(self, record):
-        try:
-            level = logger.level(record.levelname).name
-        except Exception:
-            level = record.levelno
+#         logger.opt(depth=6, exception=record.exc_info).log(level, record.getMessage())
 
-        logger.opt(depth=6, exception=record.exc_info).log(level, record.getMessage())
 
-
-logging.basicConfig(handlers=[InterceptHandler()], level=logging.INFO, force=True)
+# logging.basicConfig(handlers=[InterceptHandler()], level=logging.INFO, force=True)
 
 # Global catalog updater instance
 catalog_updater: BackgroundCatalogUpdater | None = None
@@ -46,7 +44,6 @@ async def lifespan(app: FastAPI):
             "Background catalog updates enabled (interval=%ss)",
             settings.CATALOG_REFRESH_INTERVAL_SECONDS,
         )
-
     yield
 
     # Shutdown

app/core/config.py

@@ -14,28 +14,6 @@ class Settings(BaseSettings):
     )
 
     TMDB_API_KEY: str | None = None
-    TMDB_API_URL: str = "https://api.themoviedb.org/3"
-    TMDB_ADDON_CONFIG_DICT: dict[str, str] = {
-        "provideImdbId": "true",
-        "returnImdbId": "true",
-        "language": "en-US",
-        "enableEpisodeProvider": "true",
-        "useDomain": "",
-        "cacheItemExpiryInHours": "24",
-        "returnPoster": "true",
-        "returnBackdrop": "true",
-        "returnStreamingData": "true",
-        "streamingDataLanguage": "en",
-        "disableImdbLookup": "false",
-        "type": "catalog",
-        "enableHopAgeRating": "false",
-        "enableAgeRating": "false",
-        "showAgeRatingWithImdbRating": "false",
-    }
-    TMDB_ADDON_CONFIG: str = (
-        "N4IgDgTg9gbglgEwKYEkC2CBGKEgFwgAuEArkiADQgRKEkQB26WO+Rp5VANgIYMDmJHv3IEkDALQBVAMqUQAZ2JIeaOAPwBtALpUAxj0I8uUfgq27FKiHoAWAUQY9MXJLgIAzYws4gDSgGEoEgZCfABWKgVbKAB3AEERACVDdX4UBgBxcRpzAmIyeXFnV0SkFMI0ti8uH3louLKKtIB1OEJbZkxmjU9vcgBfIA"  # noqa
-    )
-    TMDB_ADDON_HOST: str = "https://94c8cb9f702d-tmdb-addon.baby-beamup.club"
     PORT: int = 8000
     ADDON_ID: str = "com.bimal.watchly"
     ADDON_NAME: str = "Watchly"
@@ -44,16 +22,11 @@ class Settings(BaseSettings):
     TOKEN_TTL_SECONDS: int = 0  # 0 = never expire
     ANNOUNCEMENT_HTML: str = ""
     AUTO_UPDATE_CATALOGS: bool = True
-    CATALOG_REFRESH_INTERVAL_SECONDS: int = 21600  # 6 hours
+    CATALOG_REFRESH_INTERVAL_SECONDS: int = 60  # 6 hours
     APP_ENV: Literal["development", "production"] = "development"
     HOST_NAME: str = "https://1ccea4301587-watchly.baby-beamup.club"
 
-    # recommendation Settings
     RECOMMENDATION_SOURCE_ITEMS_LIMIT: int = 10
 
-    @property
-    def TMDB_ADDON_URL(self) -> str:
-        return f"{self.TMDB_ADDON_HOST}/{self.TMDB_ADDON_CONFIG}"
-
 
 settings = Settings()

app/services/catalog.py

@@ -1,6 +1,8 @@
 import asyncio
 from collections import Counter
 
+from loguru import logger
+
 from app.services.stremio_service import StremioService
 from app.services.tmdb_service import TMDBService
 
@@ -59,6 +61,32 @@ async def get_watched_loved_catalogs(self, library_items: list[dict]):
 
         return catalogs
 
+    async def _get_item_genres(self, item_id: str, item_type: str) -> list[str]:
+        """Fetch genres for a specific item from TMDB."""
+        try:
+            # Convert IMDB ID to TMDB ID
+            tmdb_id = None
+            media_type = "movie" if item_type == "movie" else "tv"
+
+            if item_id.startswith("tt"):
+                tmdb_id, _ = await self.tmdb_service.find_by_imdb_id(item_id)
+            elif item_id.startswith("tmdb:"):
+                tmdb_id = int(item_id.split(":")[1])
+
+            if not tmdb_id:
+                return []
+
+            # Fetch details
+            if media_type == "movie":
+                details = await self.tmdb_service.get_movie_details(tmdb_id)
+            else:
+                details = await self.tmdb_service.get_tv_details(tmdb_id)
+
+            return [g.get("name") for g in details.get("genres", [])]
+        except Exception as e:
+            logger.warning(f"Failed to fetch genres for {item_id}: {e}")
+            return []
+
     async def get_genre_based_catalogs(self, library_items: list[dict]):
         # get separate movies and series lists from loved items
         loved_movies = [item for item in library_items.get("loved", []) if item.get("type") == "movie"]
@@ -68,22 +96,19 @@ async def get_genre_based_catalogs(self, library_items: list[dict]):
         loved_movies = loved_movies[:5]
         loved_series = loved_series[:5]
 
-        # fetch details:: genre details from tmdb addon
-        movie_tasks = [self.tmdb_service.get_addon_meta("movie", item.get("_id").strip()) for item in loved_movies]
-        series_tasks = [self.tmdb_service.get_addon_meta("series", item.get("_id").strip()) for item in loved_series]
-        movie_details = await asyncio.gather(*movie_tasks)
-        series_details = await asyncio.gather(*series_tasks)
+        # fetch genres concurrently
+        movie_tasks = [self._get_item_genres(item.get("_id").strip(), "movie") for item in loved_movies]
+        series_tasks = [self._get_item_genres(item.get("_id").strip(), "series") for item in loved_series]
 
-        # now fetch all genres for moviees and series and sort them by their occurance
-        movie_genres = [detail.get("meta", {}).get("genres", []) for detail in movie_details]
-        series_genres = [detail.get("meta", {}).get("genres", []) for detail in series_details]
+        movie_genres_list = await asyncio.gather(*movie_tasks)
+        series_genres_list = await asyncio.gather(*series_tasks)
 
         # now flatten list and count the occurance of each genre for both movies and series separately
         movie_genre_counts = Counter(
-            [genre for sublist in movie_genres for genre in sublist if genre in MOVIE_GENRE_TO_ID_MAP]
+            [genre for sublist in movie_genres_list for genre in sublist if genre in MOVIE_GENRE_TO_ID_MAP]
         )
         series_genre_counts = Counter(
-            [genre for sublist in series_genres for genre in sublist if genre in SERIES_GENRE_TO_ID_MAP]
+            [genre for sublist in series_genres_list for genre in sublist if genre in SERIES_GENRE_TO_ID_MAP]
         )
         sorted_movie_genres = sorted(movie_genre_counts.items(), key=lambda x: x[1], reverse=True)
         sorted_series_genres = sorted(series_genre_counts.items(), key=lambda x: x[1], reverse=True)
@@ -97,22 +122,24 @@ async def get_genre_based_catalogs(self, library_items: list[dict]):
         top_2_series_genres = [str(SERIES_GENRE_TO_ID_MAP[genre_name]) for genre_name in top_2_series_genre_names]
         catalogs = []
 
-        catalogs.append(
-            {
-                "type": "movie",
-                "id": f"watchly.genre.{'_'.join(top_2_movie_genres)}",
-                "name": "You might also Like",
-                "extra": [],
-            }
-        )
-
-        catalogs.append(
-            {
-                "type": "series",
-                "id": f"watchly.genre.{'_'.join(top_2_series_genres)}",
-                "name": "You might also Like",
-                "extra": [],
-            }
-        )
+        if top_2_movie_genres:
+            catalogs.append(
+                {
+                    "type": "movie",
+                    "id": f"watchly.genre.{'_'.join(top_2_movie_genres)}",
+                    "name": "You might also Like",
+                    "extra": [],
+                }
+            )
+
+        if top_2_series_genres:
+            catalogs.append(
+                {
+                    "type": "series",
+                    "id": f"watchly.genre.{'_'.join(top_2_series_genres)}",
+                    "name": "You might also Like",
+                    "extra": [],
+                }
+            )
 
         return catalogs