feat: flat design Sunset Glitch + download manager + settings + recommendations overhaul

- Sunset Glitch color palette applied to all templates
- Font Awesome icons throughout UI
- Download manager with parallel queue and progress tracking
- Settings page with dynamic configuration
- Recommendations router enhanced with scoring
- Local vendor libs (Alpine.js, HTMX) for offline support
- Auto test suite with screenshots
- Series releases list component
- New download model

app/routers/router_anime.py

@@ -296,8 +296,7 @@ async def search_series_unified(
 
     search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
 
-    # Enrich results with metadata (synopsis, rating, genres)
-    enricher = await get_metadata_enricher()
+    # Enrich results with metadata from scrapers (not Kitsu — Kitsu is anime-only)
     enrichment_tasks = []
     enrichment_mapping = []
 
@@ -308,17 +307,15 @@ async def search_series_unified(
         elif result:
             results[provider_id] = result
             print(f"[SERIES SEARCH] {provider_id}: Found {len(result)} results")
-            # Prepare enrichment for top 15 results
-            for idx, item in enumerate(result[:15]):
-                if isinstance(item, dict):
-                    enrichment_tasks.append(
-                        enricher.enrich_metadata(
-                            item.get("metadata") or {},
-                            item.get("title") or "",
-                            item.get("url") or "",
+            # Enrich top 10 results with metadata from the scraper itself
+            downloader = series_downloaders.get(provider_id)
+            if downloader and hasattr(downloader, "get_anime_metadata"):
+                for idx, item in enumerate(result[:10]):
+                    if isinstance(item, dict) and item.get("url"):
+                        enrichment_tasks.append(
+                            downloader.get_anime_metadata(item["url"])
                         )
-                    )
-                    enrichment_mapping.append((provider_id, idx))
+                        enrichment_mapping.append((provider_id, idx))
         else:
             print(f"[SERIES SEARCH] {provider_id}: No results returned")
 
@@ -334,9 +331,7 @@ async def search_series_unified(
                     and provider_id in results
                     and pos < len(results[provider_id])
                 ):
-                    results[provider_id][pos]["metadata"] = (
-                        meta.model_dump() if hasattr(meta, "model_dump") else meta
-                    )
+                    results[provider_id][pos]["metadata"] = meta
 
     # Truncate synopses at sentence boundaries
     for pid in results:

app/routers/router_recommendations.py

@@ -3,15 +3,22 @@ Recommendations and releases routes for Ohm Stream Downloader API.
 """
 
 import hashlib
+import logging
 from datetime import datetime
-from typing import Optional
+from typing import Optional, List, Dict, Any
 
 from fastapi import APIRouter, Request, Query, HTTPException, Depends
 from fastapi.templating import Jinja2Templates
+from sqlmodel import Session, select
 
 from app.recommendation_engine import RecommendationEngine
 from app.models.auth import User
+from app.models.settings import AppSettingsTable
+from app.database import get_session
 from app.routers.router_auth import get_optional_user, get_current_user_from_token
+from app.routers.router_settings import _compute_auto_weights
+
+logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/api", tags=["recommendations"])
 templates = Jinja2Templates(directory="templates")
@@ -23,6 +30,79 @@ def hash_filter(s):
 templates.env.filters["hash"] = hash_filter
 
 
+def _get_effective_weights(session: Session, user_id: str) -> tuple:
+    """Return (anime_enabled, series_enabled, anime_weight, series_weight)."""
+    settings = session.exec(
+        select(AppSettingsTable).where(AppSettingsTable.user_id == user_id)
+    ).first()
+
+    if settings is None:
+        return True, True, 1, 1
+
+    anime_enabled = getattr(settings, 'anime_enabled', True)
+    series_enabled = getattr(settings, 'series_enabled', True)
+    mode = getattr(settings, 'content_weight_mode', 'auto')
+    download_dir = getattr(settings, 'download_dir', 'downloads')
+
+    if mode == "auto":
+        weights = _compute_auto_weights(download_dir)
+        return anime_enabled, series_enabled, weights["anime_weight"], weights["series_weight"]
+    else:
+        aw = getattr(settings, 'content_weight_anime', 2)
+        sw = getattr(settings, 'content_weight_series', 1)
+        return anime_enabled, series_enabled, int(aw), int(sw)
+
+
+def _weighted_mix(items_a: List[Dict], items_b: List[Dict], limit: int,
+                  weight_a: int = 2, weight_b: int = 1) -> List[Dict]:
+    """Mix two lists using weights. Distributes items proportionally and interleaves.
+
+    If weight_a=2, weight_b=1 and limit=15:
+      - slots_a ≈ 10, slots_b ≈ 5
+      - B items are spaced evenly across the list
+    If one list is shorter, the other fills remaining slots.
+    """
+    total_weight = weight_a + weight_b
+    if total_weight == 0:
+        return (items_a + items_b)[:limit]
+
+    slots_a = round(limit * weight_a / total_weight)
+    slots_b = limit - slots_a
+
+    pick_a = min(slots_a, len(items_a))
+    pick_b = min(slots_b, len(items_b))
+
+    # Redistribute unfilled slots
+    if pick_a < slots_a:
+        pick_b = min(pick_b + (slots_a - pick_a), len(items_b))
+    elif pick_b < slots_b:
+        pick_a = min(pick_a + (slots_b - pick_b), len(items_a))
+
+    a = items_a[:pick_a]
+    b = items_b[:pick_b]
+
+    total = pick_a + pick_b
+    if total == 0:
+        return []
+    if pick_b == 0:
+        return a[:limit]
+    if pick_a == 0:
+        return b[:limit]
+
+    # Place B items at evenly spaced positions, fill gaps with A
+    result = [None] * total
+    for i, item in enumerate(b):
+        pos = round(i * (total - 1) / max(pick_b - 1, 1))
+        result[pos] = item
+    a_idx = 0
+    for i in range(total):
+        if result[i] is None:
+            result[i] = a[a_idx]
+            a_idx += 1
+
+    return result[:limit]
+
+
 @router.get("/recommendations")
 async def get_recommendations(
     request: Request,
@@ -30,8 +110,9 @@ async def get_recommendations(
     html: bool = Query(False),
     content_type: Optional[str] = Query(None, description="Filter: 'anime', 'series', or None for all"),
     current_user: Optional[User] = Depends(get_optional_user),
+    session: Session = Depends(get_session),
 ):
-    """Get personalized anime recommendations based on download history"""
+    """Get personalized recommendations based on user settings (anime + series)"""
     is_htmx = request.headers.get("HX-Request")
 
     if current_user is None and (html or is_htmx):
@@ -42,14 +123,38 @@ async def get_recommendations(
     if current_user is None:
         raise HTTPException(status_code=401, detail="Authentication required")
 
-    engine = RecommendationEngine(download_dir="downloads")
+    anime_enabled, series_enabled, anime_weight, series_weight = _get_effective_weights(session, current_user.id)
+    recommendations = []
 
     try:
-        recommendations = await engine.get_personalized_recommendations(limit=limit)
-        
-        # Filter by content_type if specified
+        if anime_enabled:
+            engine = RecommendationEngine(download_dir="downloads")
+            try:
+                anime_recs = await engine.get_personalized_recommendations(limit=limit)
+                for r in anime_recs:
+                    r['content_type'] = 'anime'
+                recommendations.extend(anime_recs)
+            finally:
+                await engine.close()
+
+        if series_enabled:
+            try:
+                from app.downloaders.series_sites.fs7 import FS7Downloader
+                downloader = FS7Downloader()
+                series_recs = await downloader.get_latest_series(limit=limit)
+                for r in series_recs:
+                    r['content_type'] = 'series'
+                recommendations.extend(series_recs)
+            except Exception as e:
+                logger.warning(f"Series recommendations fetch failed: {e}")
+
         if content_type and content_type != "all":
-            recommendations = [r for r in recommendations if r.get("content_type", r.get("type", "")) == content_type]
+            recommendations = [r for r in recommendations if r.get("content_type") == content_type]
+        else:
+            anime_items = [r for r in recommendations if r.get("content_type") == "anime"]
+            series_items = [r for r in recommendations if r.get("content_type") == "series"]
+            recommendations = _weighted_mix(anime_items, series_items, limit,
+                                            weight_a=anime_weight, weight_b=series_weight)
 
         if html or is_htmx:
             return templates.TemplateResponse(
@@ -59,11 +164,8 @@ async def get_recommendations(
 
         return {"recommendations": recommendations, "count": len(recommendations)}
     except Exception as e:
-        import logging
-        logging.getLogger(__name__).error(f"Recommendations error: {e}", exc_info=True)
+        logger.error(f"Recommendations error: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        await engine.close()
 
 
 @router.get("/releases/latest")
@@ -72,18 +174,52 @@ async def get_latest_releases(
     limit: int = 20,
     html: bool = Query(False),
     content_type: Optional[str] = Query(None, description="Filter: 'anime', 'series', or None for all"),
+    current_user: Optional[User] = Depends(get_optional_user),
+    session: Session = Depends(get_session),
 ):
-    """Get latest anime releases"""
+    """Get latest releases based on user settings (anime + series)"""
     from app.recommendations import get_latest_releases_with_info
 
-    try:
-        releases = await get_latest_releases_with_info(limit=limit)
-        
-        # Filter by content_type if specified
-        if content_type and content_type != "all":
-            releases = [r for r in releases if r.get("content_type", r.get("type", "")) == content_type]
+    is_htmx = request.headers.get("HX-Request")
 
-        if html or request.headers.get("HX-Request"):
+    if current_user is None and (html or is_htmx):
+        return templates.TemplateResponse(
+            "components/login_prompt.html", {"request": request}
+        )
+
+    if current_user is None:
+        raise HTTPException(status_code=401, detail="Authentication required")
+
+    anime_enabled, series_enabled, anime_weight, series_weight = _get_effective_weights(session, current_user.id)
+    releases = []
+
+    try:
+        if anime_enabled:
+            anime_releases = await get_latest_releases_with_info(limit=limit)
+            for r in anime_releases:
+                r['content_type'] = 'anime'
+            releases.extend(anime_releases)
+
+        if series_enabled:
+            try:
+                from app.downloaders.series_sites.fs7 import FS7Downloader
+                downloader = FS7Downloader()
+                series_releases = await downloader.get_latest_series(limit=limit)
+                for r in series_releases:
+                    r['content_type'] = 'series'
+                releases.extend(series_releases)
+            except Exception as e:
+                logger.warning(f"Series releases fetch failed: {e}")
+
+        if content_type and content_type != "all":
+            releases = [r for r in releases if r.get("content_type") == content_type]
+        else:
+            anime_items = [r for r in releases if r.get("content_type") == "anime"]
+            series_items = [r for r in releases if r.get("content_type") == "series"]
+            releases = _weighted_mix(anime_items, series_items, limit,
+                                     weight_a=anime_weight, weight_b=series_weight)
+
+        if html or is_htmx:
             return templates.TemplateResponse(
                 "components/releases_list.html",
                 {"request": request, "releases": releases}
@@ -95,8 +231,7 @@ async def get_latest_releases(
             "updated": datetime.now().isoformat(),
         }
     except Exception as e:
-        import logging
-        logging.getLogger(__name__).error(f"Latest releases error: {e}", exc_info=True)
+        logger.error(f"Latest releases error: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e))
 
 
@@ -177,3 +312,41 @@ async def get_download_statistics(
         raise HTTPException(status_code=500, detail=str(e))
     finally:
         await engine.close()
+
+
+@router.get("/series/latest")
+async def get_latest_series(
+    request: Request,
+    limit: int = 20,
+    html: bool = Query(False),
+    current_user: Optional[User] = Depends(get_optional_user),
+):
+    """Get latest TV series releases from FS7 homepage"""
+    if current_user is None and (html or request.headers.get("HX-Request")):
+        return templates.TemplateResponse(
+            "components/login_prompt.html", {"request": request}
+        )
+
+    if current_user is None:
+        raise HTTPException(status_code=401, detail="Authentication required")
+
+    try:
+        from app.downloaders.series_sites.fs7 import FS7Downloader
+
+        downloader = FS7Downloader()
+        series = await downloader.get_latest_series(limit=limit)
+
+        if html or request.headers.get("HX-Request"):
+            return templates.TemplateResponse(
+                "components/series_releases_list.html",
+                {"request": request, "releases": series}
+            )
+
+        return {
+            "releases": series,
+            "count": len(series),
+            "updated": datetime.now().isoformat(),
+        }
+    except Exception as e:
+        logger.error(f"Latest series error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

app/routers/router_settings.py

@@ -1,6 +1,8 @@
 """Application settings routes for Ohm Stream Downloader API"""
 
 import json
+import logging
+from pathlib import Path
 from typing import List, Dict, Any, Optional
 from fastapi import APIRouter, Depends, HTTPException, Request, Response
 from fastapi.templating import Jinja2Templates
@@ -13,10 +15,74 @@ from app.routers.router_auth import get_current_user_from_token, get_optional_us
 from app.providers import get_anime_providers, get_series_providers
 from app.providers_manager import providers_manager
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/api/settings", tags=["settings"])
 templates = Jinja2Templates(directory="templates")
 
 
+def _compute_auto_weights(download_dir: str) -> Dict[str, Any]:
+    """Analyze downloaded files to compute anime vs series ratio.
+
+    Uses filename conventions:
+    - Series: contains "Saison" or "Season" keywords
+    - Anime: everything else in the downloads folder
+    Returns dict with counts and computed weights.
+    """
+    base = Path(download_dir)
+    if not base.exists():
+        return {"anime_count": 0, "series_count": 0, "anime_weight": 1, "series_weight": 1, "total": 0}
+
+    anime_count = 0
+    series_count = 0
+
+    for f in base.rglob("*"):
+        if not f.is_file():
+            continue
+        if f.suffix.lower() not in (".mp4", ".mkv", ".avi", ".wmv", ".flv", ".mov"):
+            continue
+
+        name = f.stem.lower()
+        # Heuristic: series TV files often have "Saison" or "Season" + number
+        # Anime files rarely use this format (they use "Episode" or "S01E01")
+        import re
+        if re.search(r'(?:saison|season)\s*\d+', name):
+            series_count += 1
+        else:
+            anime_count += 1
+
+    total = anime_count + series_count
+    if total == 0:
+        return {"anime_count": 0, "series_count": 0, "anime_weight": 1, "series_weight": 1, "total": 0}
+
+    # Compute weights: proportional to download count, minimum 1
+    if anime_count == 0:
+        aw, sw = 0, 1
+    elif series_count == 0:
+        aw, sw = 1, 0
+    else:
+        # Keep weights small (max 5) for reasonable interleaving
+        ratio = anime_count / series_count
+        if ratio >= 4:
+            aw, sw = 4, 1
+        elif ratio >= 2:
+            aw, sw = 2, 1
+        elif ratio >= 1:
+            aw, sw = 1, 1
+        elif ratio >= 0.5:
+            aw, sw = 1, 2
+        else:
+            aw, sw = 1, 4
+
+    return {
+        "anime_count": anime_count,
+        "series_count": series_count,
+        "anime_weight": aw,
+        "series_weight": sw,
+        "total": total,
+    }
+
+
 @router.get("", response_model=AppSettings)
 async def get_settings(
     current_user: User = Depends(get_current_user_from_token),
@@ -44,6 +110,9 @@ async def get_settings(
         anime_enabled=getattr(settings_obj, 'anime_enabled', True),
         series_enabled=getattr(settings_obj, 'series_enabled', True),
         download_dir=getattr(settings_obj, 'download_dir', 'downloads'),
+        content_weight_mode=getattr(settings_obj, 'content_weight_mode', 'auto'),
+        content_weight_anime=getattr(settings_obj, 'content_weight_anime', 2),
+        content_weight_series=getattr(settings_obj, 'content_weight_series', 1),
     )
 
 
@@ -86,6 +155,12 @@ async def update_settings(
         settings_obj.series_enabled = update_data.series_enabled
     if update_data.download_dir is not None:
         settings_obj.download_dir = update_data.download_dir
+    if update_data.content_weight_mode is not None:
+        settings_obj.content_weight_mode = update_data.content_weight_mode
+    if update_data.content_weight_anime is not None:
+        settings_obj.content_weight_anime = update_data.content_weight_anime
+    if update_data.content_weight_series is not None:
+        settings_obj.content_weight_series = update_data.content_weight_series
 
     session.add(settings_obj)
     session.commit()
@@ -98,6 +173,34 @@ async def update_settings(
     return settings_obj
 
 
+@router.get("/content-weight")
+async def get_content_weight(
+    current_user: User = Depends(get_current_user_from_token),
+    session: Session = Depends(get_session),
+):
+    """Get current effective content weights (auto-computed or manual)"""
+    statement = select(AppSettingsTable).where(
+        AppSettingsTable.user_id == current_user.id
+    )
+    settings_obj = session.exec(statement).first()
+    download_dir = getattr(settings_obj, 'download_dir', 'downloads') if settings_obj else 'downloads'
+    mode = getattr(settings_obj, 'content_weight_mode', 'auto') if settings_obj else 'auto'
+
+    if mode == "auto":
+        weights = _compute_auto_weights(download_dir)
+        weights["mode"] = "auto"
+        return weights
+    else:
+        return {
+            "mode": "manual",
+            "anime_weight": getattr(settings_obj, 'content_weight_anime', 2),
+            "series_weight": getattr(settings_obj, 'content_weight_series', 1),
+            "anime_count": None,
+            "series_count": None,
+            "total": None,
+        }
+
+
 @router.get("/providers/availability")
 async def get_providers_availability(
     current_user: User = Depends(get_current_user_from_token),

app/routers/router_watchlist.py

@@ -213,7 +213,7 @@ async def delete_from_watchlist(
     raise HTTPException(status_code=500, detail="Failed to delete item")
 
 
-@router.post("/check", response_model=List)
+@router.post("/check")
 async def check_watchlist_now(
     background_tasks: BackgroundTasks,
     response: Response,