feat: add options to select minimum and maximum number of items in catalogs (#54)

TimilsinaBimal · web-flow · commit 39c08f461e77 · 2025-12-16T13:48:45.000+05:45
diff --git a/app/api/endpoints/catalogs.py b/app/api/endpoints/catalogs.py
@@ -3,6 +3,7 @@
 from fastapi import APIRouter, HTTPException, Response
 from loguru import logger
 
+from app.api.endpoints.manifest import get_config_id
 from app.core.security import redact_token
 from app.core.settings import UserSettings, get_default_settings
 from app.services.catalog_updater import refresh_catalogs_for_credentials
@@ -11,6 +12,8 @@
 from app.services.token_store import token_store
 
 MAX_RESULTS = 50
+DEFAULT_MIN_ITEMS = 20
+DEFAULT_MAX_ITEMS = 32
 SOURCE_ITEMS_LIMIT = 10
 
 router = APIRouter()
@@ -30,7 +33,14 @@ async def get_catalog(type: str, id: str, response: Response, token: str):
 
     # Supported IDs now include dynamic themes and item-based rows
     if id != "watchly.rec" and not any(
-        id.startswith(p) for p in ("tt", "watchly.theme.", "watchly.item.", "watchly.loved.", "watchly.watched.")
+        id.startswith(p)
+        for p in (
+            "tt",
+            "watchly.theme.",
+            "watchly.item.",
+            "watchly.loved.",
+            "watchly.watched.",
+        )
     ):
         logger.warning(f"Invalid id: {id}")
         raise HTTPException(
@@ -64,32 +74,80 @@ async def get_catalog(type: str, id: str, response: Response, token: str):
             library_data=library_items,
         )
 
+        # Resolve per-catalog limits (min/max)
+        def _get_limits() -> tuple[int, int]:
+            try:
+                cfg_id = get_config_id({"id": id})
+            except Exception:
+                cfg_id = id
+            try:
+                cfg = next((c for c in user_settings.catalogs if c.id == cfg_id), None)
+                if cfg and hasattr(cfg, "min_items") and hasattr(cfg, "max_items"):
+                    return int(cfg.min_items or DEFAULT_MIN_ITEMS), int(cfg.max_items or DEFAULT_MAX_ITEMS)
+            except Exception:
+                pass
+            return DEFAULT_MIN_ITEMS, DEFAULT_MAX_ITEMS
+
+        min_items, max_items = _get_limits()
+        # Enforce caps: min_items <= 20, max_items <= 32 and max >= min
+        try:
+            min_items = max(1, min(DEFAULT_MIN_ITEMS, int(min_items)))
+            max_items = max(min_items, min(DEFAULT_MAX_ITEMS, int(max_items)))
+        except (ValueError, TypeError):
+            logger.warning(
+                f"Invalid min/max items values. Falling back to defaults. min_items={min_items}, max_items={max_items}"
+            )
+            min_items, max_items = DEFAULT_MIN_ITEMS, DEFAULT_MAX_ITEMS
+
         # Handle item-based recommendations
         if id.startswith("tt"):
+            try:
+                recommendation_service.per_item_limit = max_items
+            except Exception:
+                pass
             recommendations = await recommendation_service.get_recommendations_for_item(item_id=id)
+            if len(recommendations) < min_items:
+                recommendations = await recommendation_service.pad_to_min(type, recommendations, min_items)
             logger.info(f"Found {len(recommendations)} recommendations for {id}")
 
-        elif id.startswith("watchly.item.") or id.startswith("watchly.loved.") or id.startswith("watchly.watched."):
+        elif any(
+            id.startswith(p)
+            for p in (
+                "watchly.item.",
+                "watchly.loved.",
+                "watchly.watched.",
+            )
+        ):
             # Extract actual item ID (tt... or tmdb:...)
             item_id = re.sub(r"^watchly\.(item|loved|watched)\.", "", id)
+            try:
+                recommendation_service.per_item_limit = max_items
+            except Exception:
+                pass
             recommendations = await recommendation_service.get_recommendations_for_item(item_id=item_id)
+            if len(recommendations) < min_items:
+                recommendations = await recommendation_service.pad_to_min(type, recommendations, min_items)
             logger.info(f"Found {len(recommendations)} recommendations for item {item_id}")
 
         elif id.startswith("watchly.theme."):
-            recommendations = await recommendation_service.get_recommendations_for_theme(theme_id=id, content_type=type)
+            recommendations = await recommendation_service.get_recommendations_for_theme(
+                theme_id=id, content_type=type, limit=max_items
+            )
+            if len(recommendations) < min_items:
+                recommendations = await recommendation_service.pad_to_min(type, recommendations, min_items)
             logger.info(f"Found {len(recommendations)} recommendations for theme {id}")
 
         else:
             recommendations = await recommendation_service.get_recommendations(
-                content_type=type, source_items_limit=SOURCE_ITEMS_LIMIT, max_results=MAX_RESULTS
+                content_type=type, source_items_limit=SOURCE_ITEMS_LIMIT, max_results=max_items
             )
+            if len(recommendations) < min_items:
+                recommendations = await recommendation_service.pad_to_min(type, recommendations, min_items)
             logger.info(f"Found {len(recommendations)} recommendations for {type}")
 
         logger.info(f"Returning {len(recommendations)} items for {type}")
-        # Cache catalog responses for 4 hours
-        response.headers["Cache-Control"] = (
-            "public, max-age=14400" if len(recommendations) > 0 else "public, max-age=7200"
-        )
+        # Avoid serving stale results; revalidate on each request
+        response.headers["Cache-Control"] = "no-cache"
         return {"metas": recommendations}
 
     except HTTPException:
diff --git a/app/core/settings.py b/app/core/settings.py
@@ -5,6 +5,8 @@ class CatalogConfig(BaseModel):
     id: str  # "watchly.rec", "watchly.theme", "watchly.item"
     name: str | None = None
     enabled: bool = True
+    min_items: int = Field(default=20, ge=1, le=20)
+    max_items: int = Field(default=24, ge=1, le=32)
 
 
 class UserSettings(BaseModel):
diff --git a/app/core/version.py b/app/core/version.py
@@ -1 +1 @@
-__version__ = "1.1.4"
+__version__ = "1.2.0"
diff --git a/app/services/recommendation_service.py b/app/services/recommendation_service.py
@@ -598,6 +598,95 @@ def _passes_top_genre(item_genre_ids: list[int] | None) -> bool:
         logger.info(f"Found {len(final_items)} valid recommendations for {item_id}")
         return final_items
 
+    async def pad_to_min(self, content_type: str, existing: list[dict], min_items: int) -> list[dict]:
+        """Pad results with trending/top-rated to satisfy a minimum count.
+        Returns a new list with extra items appended (deduped).
+        """
+        try:
+            need = max(0, int(min_items) - len(existing))
+        except Exception:
+            need = 0
+        if need <= 0:
+            return existing
+
+        # Build exclusion and whitelist
+        watched_imdb, watched_tmdb = await self._get_exclusion_sets()
+        excluded_ids = set(self._get_excluded_genre_ids(content_type))
+        whitelist = await self._get_top_genre_whitelist(content_type)
+
+        def _passes(item: dict) -> bool:
+            gids = set(item.get("genre_ids") or [])
+            if gids and excluded_ids and excluded_ids.intersection(gids):
+                return False
+            if whitelist:
+                if 16 in gids and 16 not in whitelist:
+                    return False
+                if gids and not (gids & whitelist):
+                    return False
+            return True
+
+        # Seed pool from trending and top rated
+        mtype = "tv" if content_type in ("tv", "series") else "movie"
+        pool = []
+        try:
+            tr = await self.tmdb_service.get_trending(mtype, time_window="week")
+            pool.extend(tr.get("results", [])[:60])
+        except Exception as e:
+            logger.warning(f"Failed to fetch trending items for padding: {e}")
+        try:
+            tr2 = await self.tmdb_service.get_top_rated(mtype)
+            pool.extend(tr2.get("results", [])[:60])
+        except Exception as e:
+            logger.warning(f"Failed to fetch top rated items for padding: {e}")
+
+        # Filter and dedup by tmdb id
+        existing_tmdb = set()
+        for it in existing:
+            tid = it.get("_tmdb_id") or it.get("tmdb_id") or it.get("id")
+            try:
+                if isinstance(tid, str) and tid.startswith("tmdb:"):
+                    tid = int(tid.split(":")[1])
+                tid = int(tid)
+                existing_tmdb.add(tid)
+            except Exception:
+                pass
+
+        dedup = {}
+        for it in pool:
+            tid = it.get("id")
+            if not tid or tid in existing_tmdb or tid in watched_tmdb:
+                continue
+            if not _passes(it):
+                continue
+            # quality gate
+            va = float(it.get("vote_average") or 0.0)
+            vc = int(it.get("vote_count") or 0)
+            if vc < 100 or va < 6.2:
+                continue
+            dedup[tid] = it
+            if len(dedup) >= need * 3:
+                break
+
+        if not dedup:
+            return existing
+
+        # Fetch metadata to convert to enriched items and IMDB ids
+        meta = await self._fetch_metadata_for_items(list(dedup.values()), content_type, target_count=need * 2)
+
+        # Filter out watched/duplicates after enrichment
+        extra = []
+        existing_ids = {it.get("id") for it in existing}
+        for it in meta:
+            if it.get("id") in existing_ids:
+                continue
+            if it.get("id") in watched_imdb:
+                continue
+            if len(extra) >= need:
+                break
+            extra.append(it)
+
+        return existing + extra
+
     def _get_excluded_genre_ids(self, content_type: str) -> list[int]:
         if not self.user_settings:
             return []
@@ -823,7 +912,9 @@ async def get_recommendations(
         if self._library_data is None:
             self._library_data = await self.stremio_service.get_library_items()
         library_data = self._library_data
-        all_items = library_data.get("loved", []) + library_data.get("watched", []) + library_data.get("added", [])
+        all_items = library_data.get("loved", [])
+        all_items += library_data.get("watched", [])
+        all_items += library_data.get("added", [])
         logger.info(f"processing {len(all_items)} Items.")
         # Cold-start fallback remains (redundant safety)
         if not all_items:
diff --git a/app/static/index.html b/app/static/index.html
@@ -101,6 +101,26 @@
             overscroll-behavior: contain;
         }
 
+        /* High-contrast text selection to avoid blending with blue OS highlight */
+        ::selection {
+            background: rgba(59, 130, 246, 0.35); /* blue-500 @ 35% */
+            color: #ffffff;
+        }
+        ::-moz-selection {
+            background: rgba(59, 130, 246, 0.35);
+            color: #ffffff;
+        }
+        input::selection, textarea::selection {
+            background: rgba(59, 130, 246, 0.45);
+            color: #ffffff;
+        }
+        input::-moz-selection, textarea::-moz-selection {
+            background: rgba(59, 130, 246, 0.45);
+            color: #ffffff;
+        }
+        /* Ensure caret is visible on dark inputs */
+        input, textarea { caret-color: #ffffff; }
+
         /* Animated hamburger icon */
         .hamburger {
             position: relative;
@@ -128,6 +148,16 @@
         @media (prefers-reduced-motion: reduce) {
             .hamburger .bar { transition: none; }
         }
+
+        /* Number input: hide native spinners; we provide custom +/- */
+        input.stepper-input[type=number]::-webkit-outer-spin-button,
+        input.stepper-input[type=number]::-webkit-inner-spin-button {
+            -webkit-appearance: none;
+            margin: 0;
+        }
+        input.stepper-input[type=number] {
+            -moz-appearance: textfield;
+        }
     </style>
 </head>
 
diff --git a/app/static/script.js b/app/static/script.js
@@ -1,9 +1,9 @@
 // Default catalog configurations
 const defaultCatalogs = [
-    { id: 'watchly.rec', name: 'Top Picks for You', enabled: true, description: 'Personalized recommendations based on your library' },
-    { id: 'watchly.loved', name: 'More Like', enabled: true, description: 'Recommendations similar to content you explicitly loved' },
-    { id: 'watchly.watched', name: 'Because You Watched', enabled: true, description: 'Recommendations based on your recent watch history' },
-    { id: 'watchly.theme', name: 'Genre & Keyword Catalogs', enabled: true, description: 'Dynamic catalogs based on your favorite genres, keyword, countries and many more. Just like netflix. Example: American Horror, Based on Novel or Book etc.' },
+    { id: 'watchly.rec', name: 'Top Picks for You', enabled: true, minItems: 20, maxItems: 24, description: 'Personalized recommendations based on your library' },
+    { id: 'watchly.loved', name: 'More Like', enabled: true, minItems: 20, maxItems: 24, description: 'Recommendations similar to content you explicitly loved' },
+    { id: 'watchly.watched', name: 'Because You Watched', enabled: true, minItems: 20, maxItems: 24, description: 'Recommendations based on your recent watch history' },
+    { id: 'watchly.theme', name: 'Genre & Keyword Catalogs', enabled: true, minItems: 20, maxItems: 24, description: 'Dynamic catalogs based on your favorite genres, keyword, countries and many more. Just like netflix. Example: American Horror, Based on Novel or Book etc.' },
 ];
 
 let catalogs = JSON.parse(JSON.stringify(defaultCatalogs));
@@ -350,6 +350,8 @@ async function fetchStremioIdentity(authKey) {
                     if (local) {
                         local.enabled = remote.enabled;
                         if (remote.name) local.name = remote.name;
+                        if (typeof remote.min_items === 'number') local.minItems = remote.min_items;
+                        if (typeof remote.max_items === 'number') local.maxItems = remote.max_items;
                     }
                 });
                 renderCatalogList();
@@ -472,10 +474,19 @@ async function initializeFormSubmission() {
             const enabled = toggle.checked;
             const originalCatalog = catalogs.find(c => c.id === catalogId);
             if (originalCatalog) {
+                let minV = parseInt(originalCatalog.minItems ?? 20, 10);
+                let maxV = parseInt(originalCatalog.maxItems ?? 24, 10);
+                if (Number.isNaN(minV)) minV = 20;
+                if (Number.isNaN(maxV)) maxV = 24;
+                // Enforce server policy: min <= 20, max <= 32, and max >= min
+                minV = Math.max(1, Math.min(20, minV));
+                maxV = Math.max(minV, Math.min(32, maxV));
                 catalogsToSend.push({
                     id: catalogId,
                     name: originalCatalog.name,
-                    enabled: enabled
+                    enabled: enabled,
+                    min_items: minV,
+                    max_items: maxV,
                 });
             }
         });
@@ -610,6 +621,7 @@ function createCatalogItem(cat, index) {
     const disabledClass = !cat.enabled ? 'opacity-50' : '';
     // Modern neutral glass card to match new theme
     item.className = `catalog-item group bg-neutral-900/60 border border-white/10 rounded-xl p-4 backdrop-blur-sm transition-all hover:border-white/20 hover:bg-neutral-900/70 hover:shadow-lg hover:shadow-black/20 ${disabledClass}`;
+    item.setAttribute('data-id', cat.id);
     item.setAttribute('data-index', index);
 
     const isRenamable = cat.id !== 'watchly.theme';
@@ -637,6 +649,24 @@ function createCatalogItem(cat, index) {
             </label>
         </div>
         <div class="catalog-desc hidden sm:block text-xs text-slate-500 mt-2 ml-8 pl-1">${escapeHtml(cat.description || '')}</div>
+        <div class="mt-3 grid grid-cols-2 gap-3 ml-8">
+            <div class="text-xs text-slate-400 flex items-center gap-2">
+                <span class="whitespace-nowrap">Min items</span>
+                <div class="flex items-center gap-2 bg-neutral-950 border border-white/10 rounded-lg px-2 py-1">
+                    <button type="button" class="btn-minus step-btn text-slate-300 hover:text-white hover:bg-white/10 rounded-md px-2 py-1" aria-label="Decrease minimum">−</button>
+                    <input type="number" name="min-items" min="1" max="20" value="${(cat.minItems ?? 20)}" class="stepper-input w-16 bg-transparent outline-none text-white text-sm text-center" />
+                    <button type="button" class="btn-plus step-btn text-slate-300 hover:text-white hover:bg-white/10 rounded-md px-2 py-1" aria-label="Increase minimum">+</button>
+                </div>
+            </div>
+            <div class="text-xs text-slate-400 flex items-center gap-2">
+                <span class="whitespace-nowrap">Max items</span>
+                <div class="flex items-center gap-2 bg-neutral-950 border border-white/10 rounded-lg px-2 py-1">
+                    <button type="button" class="btn-minus-max step-btn text-slate-300 hover:text-white hover:bg-white/10 rounded-md px-2 py-1" aria-label="Decrease maximum">−</button>
+                    <input type="number" name="max-items" min="1" max="32" value="${(cat.maxItems ?? 24)}" class="stepper-input w-16 bg-transparent outline-none text-white text-sm text-center" />
+                    <button type="button" class="btn-plus-max step-btn text-slate-300 hover:text-white hover:bg-white/10 rounded-md px-2 py-1" aria-label="Increase maximum">+</button>
+                </div>
+            </div>
+        </div>
     `;
 
     if (isRenamable) setupRenameLogic(item, cat);
@@ -651,6 +681,36 @@ function createCatalogItem(cat, index) {
     item.querySelector('.move-up').addEventListener('click', (e) => { e.preventDefault(); moveCatalogUp(index); });
     item.querySelector('.move-down').addEventListener('click', (e) => { e.preventDefault(); moveCatalogDown(index); });
 
+    // keep min/max in model
+    const minEl = item.querySelector("input[name='min-items']");
+    const maxEl = item.querySelector("input[name='max-items']");
+    const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+    const sync = () => {
+        let minV = parseInt(minEl.value || '20', 10);
+        let maxV = parseInt(maxEl.value || '24', 10);
+        if (Number.isNaN(minV)) minV = 20;
+        if (Number.isNaN(maxV)) maxV = 24;
+        minV = clamp(minV, 1, 20);
+        maxV = clamp(maxV, 1, 32);
+        if (maxV < minV) maxV = minV;
+        minEl.value = String(minV);
+        maxEl.value = String(maxV);
+        cat.minItems = minV;
+        cat.maxItems = maxV;
+    };
+    minEl.addEventListener('change', sync);
+    maxEl.addEventListener('change', sync);
+
+    const inc = (el, delta) => { el.value = String((parseInt(el.value || '0', 10) || 0) + delta); sync(); };
+    const btnMinMinus = item.querySelector('.btn-minus');
+    const btnMinPlus = item.querySelector('.btn-plus');
+    const btnMaxMinus = item.querySelector('.btn-minus-max');
+    const btnMaxPlus = item.querySelector('.btn-plus-max');
+    btnMinMinus.addEventListener('click', () => inc(minEl, -1));
+    btnMinPlus.addEventListener('click', () => inc(minEl, +1));
+    btnMaxMinus.addEventListener('click', () => inc(maxEl, -1));
+    btnMaxPlus.addEventListener('click', () => inc(maxEl, +1));
+
     return item;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-__version__ = "1.1.4"`
	`1`	`+__version__ = "1.2.0"`