Implement multi-site Torznab API support

- Update Torznab search and tvsearch endpoints to handle (site, slug) tuples
- Add site parameter to probe_episode_quality
- Update availability caching with site parameter
- Site-specific language defaults (English Dub for s.to)
- Site-aware GUID prefixes (aw: vs sto:)
- Update tests to match new multi-site API
- All 32 tests passing

Co-authored-by: Zzackllack <149129501+Zzackllack@users.noreply.github.com>

Author: Copilot

app/api/torznab/api.py

@@ -85,29 +85,37 @@ def torznab_api(
             )
         elif q_str:
             # Preview search: S01E01 for requested series
-            slug = tn._slug_from_query(q_str)
-            if slug:
-                display_title = tn.resolve_series_title(slug) or q_str
+            result = tn._slug_from_query(q_str)
+            if result:
+                site_found, slug = result
+                display_title = tn.resolve_series_title(slug, site_found) or q_str
                 season_i, ep_i = 1, 1
                 cached_langs = tn.list_available_languages_cached(
-                    session, slug=slug, season=season_i, episode=ep_i
+                    session, slug=slug, season=season_i, episode=ep_i, site=site_found
                 )
+                
+                # Default languages based on site
+                if site_found == "s.to":
+                    default_langs = ["German Dub", "English Dub", "German Sub"]
+                else:
+                    default_langs = ["German Dub", "German Sub", "English Sub"]
+                    
                 candidate_langs: List[str] = (
                     cached_langs
                     if cached_langs
-                    else ["German Dub", "German Sub", "English Sub"]
+                    else default_langs
                 )
                 now = datetime.now(timezone.utc)
                 count = 0
                 for lang in candidate_langs:
                     try:
                         available, h, vc, prov, _info = tn.probe_episode_quality(
-                            slug=slug, season=season_i, episode=ep_i, language=lang
+                            slug=slug, season=season_i, episode=ep_i, language=lang, site=site_found
                         )
                     except Exception as e:
                         logger.error(
-                            "Error probing preview quality for slug={}, S{}E{}, lang={}: {}".format(
-                                slug, season_i, ep_i, lang, e
+                            "Error probing preview quality for slug={}, S{}E{}, lang={}, site={}: {}".format(
+                                slug, season_i, ep_i, lang, site_found, e
                             )
                         )
                         continue
@@ -123,11 +131,12 @@ def torznab_api(
                             vcodec=vc,
                             provider=prov,
                             extra=None,
+                            site=site_found,
                         )
                     except Exception as e:
                         logger.error(
-                            "Error upserting preview availability for slug={}, S{}E{}, lang={}: {}".format(
-                                slug, season_i, ep_i, lang, e
+                            "Error upserting preview availability for slug={}, S{}E{}, lang={}, site={}: {}".format(
+                                slug, season_i, ep_i, lang, site_found, e
                             )
                         )
                     if not available:
@@ -139,6 +148,7 @@ def torznab_api(
                         height=h,
                         vcodec=vc,
                         language=lang,
+                        site=site_found,
                     )
                     try:
                         magnet = tn.build_magnet(
@@ -148,14 +158,17 @@ def torznab_api(
                             episode=ep_i,
                             language=lang,
                             provider=prov,
+                            site=site_found,
                         )
                     except Exception as e:
                         logger.error(
                             f"Error building magnet for release '{release_title}': {e}"
                         )
                         continue
 
-                    guid = f"aw:{slug}:s{season_i}e{ep_i}:{lang}"
+                    # Use site-appropriate prefix for GUID
+                    prefix = "aw" if site_found == "aniworld.to" else "sto"
+                    guid = f"{prefix}:{slug}:s{season_i}e{ep_i}:{lang}"
                     try:
                         _build_item(
                             channel=channel,
@@ -201,25 +214,33 @@ def torznab_api(
     logger.debug(
         f"Searching for slug for query '{q_str}' (season={season_i}, ep={ep_i})"
     )
-    slug = tn._slug_from_query(q_str)
-    if not slug:
+    result = tn._slug_from_query(q_str)
+    if not result:
         logger.warning(f"No slug found for query '{q_str}'. Returning empty RSS feed.")
         rss, _channel = _rss_root()
         xml = ET.tostring(rss, encoding="utf-8", xml_declaration=True).decode("utf-8")
         return Response(content=xml, media_type="application/rss+xml; charset=utf-8")
 
-    display_title = tn.resolve_series_title(slug) or q_str
-    logger.debug(f"Resolved display title: '{display_title}' for slug '{slug}'")
+    site_found, slug = result
+    display_title = tn.resolve_series_title(slug, site_found) or q_str
+    logger.debug(f"Resolved display title: '{display_title}' for slug '{slug}' on site '{site_found}'")
 
     # language candidates from cache or defaults
     cached_langs = tn.list_available_languages_cached(
-        session, slug=slug, season=season_i, episode=ep_i
+        session, slug=slug, season=season_i, episode=ep_i, site=site_found
     )
+    
+    # Default languages based on site
+    if site_found == "s.to":
+        default_langs = ["German Dub", "English Dub", "German Sub"]
+    else:
+        default_langs = ["German Dub", "German Sub", "English Sub"]
+        
     candidate_langs: List[str] = (
-        cached_langs if cached_langs else ["German Dub", "German Sub", "English Sub"]
+        cached_langs if cached_langs else default_langs
     )
     logger.debug(
-        f"Candidate languages for slug '{slug}', season {season_i}, episode {ep_i}: {candidate_langs}"
+        f"Candidate languages for slug '{slug}', season {season_i}, episode {ep_i}, site '{site_found}': {candidate_langs}"
     )
 
     rss, channel = _rss_root()
@@ -231,12 +252,12 @@ def torznab_api(
         # check cache per language
         try:
             rec = tn.get_availability(
-                session, slug=slug, season=season_i, episode=ep_i, language=lang
+                session, slug=slug, season=season_i, episode=ep_i, language=lang, site=site_found
             )
         except Exception as e:
             logger.error(
-                "Error reading availability cache for slug={}, S{}E{}, lang={}: {}".format(
-                    slug, season_i, ep_i, lang, e
+                "Error reading availability cache for slug={}, S{}E{}, lang={}, site={}: {}".format(
+                    slug, season_i, ep_i, lang, site_found, e
                 )
             )
             rec = None
@@ -252,16 +273,16 @@ def torznab_api(
             vcodec = rec.vcodec
             prov_used = rec.provider
             logger.debug(
-                f"Using cached availability for {slug} S{season_i}E{ep_i} {lang}: h={height}, vcodec={vcodec}, prov={prov_used}"
+                f"Using cached availability for {slug} S{season_i}E{ep_i} {lang} on {site_found}: h={height}, vcodec={vcodec}, prov={prov_used}"
             )
         else:
             try:
                 available, height, vcodec, prov_used, _info = tn.probe_episode_quality(
-                    slug=slug, season=season_i, episode=ep_i, language=lang
+                    slug=slug, season=season_i, episode=ep_i, language=lang, site=site_found
                 )
             except Exception as e:
                 logger.error(
-                    f"Error probing quality for slug={slug}, S{season_i}E{ep_i}, lang={lang}: {e}"
+                    f"Error probing quality for slug={slug}, S{season_i}E{ep_i}, lang={lang}, site={site_found}: {e}"
                 )
                 available = False
 
@@ -277,15 +298,16 @@ def torznab_api(
                     vcodec=vcodec,
                     provider=prov_used,
                     extra=None,
+                    site=site_found,
                 )
             except Exception as e:
                 logger.error(
-                    f"Error upserting availability for slug={slug}, S{season_i}E{ep_i}, lang={lang}: {e}"
+                    f"Error upserting availability for slug={slug}, S{season_i}E{ep_i}, lang={lang}, site={site_found}: {e}"
                 )
 
         if not available:
             logger.debug(
-                f"Language '{lang}' currently not available for {slug} S{season_i}E{ep_i}. Skipping."
+                f"Language '{lang}' currently not available for {slug} S{season_i}E{ep_i} on {site_found}. Skipping."
             )
             continue
 
@@ -297,6 +319,7 @@ def torznab_api(
             height=height,
             vcodec=vcodec,
             language=lang,
+            site=site_found,
         )
         logger.debug(f"Built release title: '{release_title}'")
 
@@ -308,12 +331,15 @@ def torznab_api(
                 episode=ep_i,
                 language=lang,
                 provider=prov_used,
+                site=site_found,
             )
         except Exception as e:
             logger.error(f"Error building magnet for release '{release_title}': {e}")
             continue
 
-        guid = f"aw:{slug}:s{season_i}e{ep_i}:{lang}"
+        # Use site-appropriate prefix for GUID
+        prefix = "aw" if site_found == "aniworld.to" else "sto"
+        guid = f"{prefix}:{slug}:s{season_i}e{ep_i}:{lang}"
 
         try:
             _build_item(

app/api/torznab/utils.py

@@ -70,42 +70,28 @@ def _normalize_tokens(s: str) -> List[str]:
     return "".join(ch.lower() if ch.isalnum() else " " for ch in s).split()
 
 
-def _slug_from_query(q: str) -> Optional[str]:
-    """Map free-text query -> slug using main and alternative titles.
-
-    Import from the torznab package namespace so tests that monkeypatch
-    `app.api.torznab.load_or_refresh_index` affect this function too.
+def _slug_from_query(q: str, site: Optional[str] = None) -> Optional[Tuple[str, str]]:
+    """Map free-text query -> (site, slug) using main and alternative titles.
+    
+    If site is specified, only searches that site. Otherwise searches all enabled sites.
+    Returns (site, slug) tuple or None.
+    
+    Import from the title_resolver module for the actual implementation.
     """
-    logger.debug(f"Resolving slug from query: '{q}'")
-    import app.api.torznab as tn
-
-    index = tn.load_or_refresh_index()  # slug -> display title
-    alts = tn.load_or_refresh_alternatives()  # slug -> [titles]
-    q_tokens = set(_normalize_tokens(q))
-    best_slug: Optional[str] = None
-    best_score = 0
-
-    for s, title in index.items():
-        candidates: List[str] = [title]
-        if s in alts and alts[s]:
-            candidates.extend(alts[s])
-        local_best = 0
-        for cand in candidates:
-            t_tokens = set(_normalize_tokens(cand))
-            inter = len(q_tokens & t_tokens)
-            if inter > local_best:
-                local_best = inter
-        if local_best > best_score:
-            best_score = local_best
-            best_slug = s
-
-    if not best_slug:
-        logger.warning(f"No slug match found for query: '{q}'")
-    else:
+    logger.debug(f"Resolving slug from query: '{q}', site filter: {site}")
+    from app.utils.title_resolver import slug_from_query
+    
+    # Use the new multi-site slug_from_query
+    result = slug_from_query(q, site)
+    if result:
+        site_found, slug_found = result
         logger.debug(
-            f"Best slug match for '{q}' is '{best_slug}' with score {best_score}"
+            f"Best match for '{q}' is slug '{slug_found}' on site '{site_found}'"
         )
-    return best_slug
+        return (site_found, slug_found)
+    else:
+        logger.warning(f"No slug match found for query: '{q}'")
+        return None
 
 
 def _add_torznab_attr(item: ET.Element, name: str, value: str) -> None:

app/utils/probe_quality.py

@@ -58,16 +58,17 @@ def probe_episode_quality(
     language: str,
     preferred_provider: Optional[str] = None,
     timeout: float = 6.0,
+    site: str = "aniworld.to",
 ) -> tuple[bool, Optional[int], Optional[str], Optional[str], Dict[str, Any] | None]:
     """
     Gibt zurück: (available, height, vcodec, provider_used, raw_info)
       - available=False, wenn kein Provider/Language funktioniert.
     """
     logger.info(
         f"Probing episode quality for slug={slug}, season={season}, episode={episode}, language={language}, "
-        f"preferred_provider={preferred_provider}, timeout={timeout}"
+        f"preferred_provider={preferred_provider}, timeout={timeout}, site={site}"
     )
-    ep = build_episode(slug=slug, season=season, episode=episode)
+    ep = build_episode(slug=slug, season=season, episode=episode, site=site)
     logger.debug(f"Built episode object: {ep}")
     candidates: List[str] = []
     if preferred_provider:

tests/test_torznab.py

@@ -24,27 +24,28 @@ class Rec:
         vcodec = "h264"
         provider = "prov"
 
-    monkeypatch.setattr(tn, "_slug_from_query", lambda q: "slug")
-    monkeypatch.setattr(tn, "resolve_series_title", lambda slug: "Series")
+    # Return (site, slug) tuple for new multi-site API
+    monkeypatch.setattr(tn, "_slug_from_query", lambda q, site=None: ("aniworld.to", "slug"))
+    monkeypatch.setattr(tn, "resolve_series_title", lambda slug, site="aniworld.to": "Series")
     monkeypatch.setattr(
         tn,
         "list_available_languages_cached",
-        lambda session, slug, season, episode: ["German Dub"],
+        lambda session, slug, season, episode, site="aniworld.to": ["German Dub"],
     )
     monkeypatch.setattr(
         tn,
         "get_availability",
-        lambda session, slug, season, episode, language: Rec(),
+        lambda session, slug, season, episode, language, site="aniworld.to": Rec(),
     )
     monkeypatch.setattr(
         tn,
         "build_release_name",
-        lambda series_title, season, episode, height, vcodec, language: "Title",
+        lambda series_title, season, episode, height, vcodec, language, site="aniworld.to": "Title",
     )
     monkeypatch.setattr(
         tn,
         "build_magnet",
-        lambda title, slug, season, episode, language, provider: "magnet:?xt=urn:btih:test&dn=Title&aw_slug=slug&aw_s=1&aw_e=1&aw_lang=German+Dub",
+        lambda title, slug, season, episode, language, provider, site="aniworld.to": "magnet:?xt=urn:btih:test&dn=Title&aw_slug=slug&aw_s=1&aw_e=1&aw_lang=German+Dub&aw_site=aniworld.to",
     )
 
     resp = client.get(

tests/test_torznab_utils.py

@@ -8,8 +8,16 @@ def test_caps_xml_parses():
 
 
 def test_slug_from_query_basic(monkeypatch):
-    from app.api import torznab as tn
+    from app.api.torznab import utils as torznab_utils
+    from app import utils as app_utils
 
-    monkeypatch.setattr(tn, "load_or_refresh_index", lambda: {"slug": "My Title"})
-    assert tn._slug_from_query("My Title") == "slug"
-    assert tn._slug_from_query("Unknown") is None
+    # Mock the title_resolver slug_from_query
+    def mock_slug_from_query(q, site=None):
+        if "My Title" in q:
+            return ("aniworld.to", "slug")
+        return None
+    
+    monkeypatch.setattr(app_utils.title_resolver, "slug_from_query", mock_slug_from_query)
+    result = torznab_utils._slug_from_query("My Title")
+    assert result == ("aniworld.to", "slug")
+    assert torznab_utils._slug_from_query("Unknown") is None