Roman/ohm_streaming
1
0
Fork 0
Code Issues Pull Requests 2 Actions Packages Projects Releases Wiki Activity

fix: migrations, auth, providers health check, E2E tests, remove neko-sama
CI / Test (Python 3.11) (push) Has been cancelled
Details
CI / Test (Python 3.12) (push) Has been cancelled
Details
CI / Lint (push) Has been cancelled
Details
CI / Type Check (push) Has been cancelled
Details
CI / Summary (push) Has been cancelled
Details

Browse Source 
- Add proper Alembic initial migration (0001_initial_schema.py)
- Migrate refresh tokens from JSON file to SQLite (RefreshTokenTable)
- Remove Neko-Sama provider entirely (redirects to Gupy, not a host)
- Fix provider health check always showing UNKNOWN
  - Run check_all_health() on startup
  - Fix POST /providers/health/check background task bug
  - Add HTMX refresh after manual health check trigger
- Fix anime search relevance scoring with MIN_RELEVANCE_THRESHOLD=0.5
- Replace bare 'except:' with 'except Exception:' across codebase
- Add Playwright E2E test suite (12 tests, auth setup, helpers)
- Fix toast container blocking clicks via pointer-events: none
- Remove obsolete Jest/Vite test files and config
- Clean up obsolete test_watchlist scripts
- Update sonarr model comment for active providers
This commit is contained in:
Kimi Agent
2026-05-12 11:45:56 +00:00
parent 693615a7dc
commit 520be53901
47 changed files with 654 additions and 3437 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/auth.py
+41 -48
View File
@@ -1,9 +1,7 @@
"""User authentication and management system with SQLModel support"""
import os
import hashlib
from datetime import datetime, timedelta
from typing import Optional, Dict, List
from typing import Optional
from jose import jwt
from passlib.context import CryptContext
import logging
@@ -11,7 +9,7 @@ from fastapi import HTTPException
from fastapi.security import HTTPAuthorizationCredentials
from sqlmodel import Session, select
from app.database import engine
from app.models.auth import UserTable
from app.models.auth import UserTable, RefreshTokenTable
from app.config import get_settings
logger = logging.getLogger(__name__)
@@ -189,33 +187,32 @@ def get_current_user(credentials: HTTPAuthorizationCredentials) -> UserTable:
raise HTTPException(status_code=401, detail="Invalid authentication credentials")
# Refresh tokens storage
REFRESH_TOKENS_FILE = "config/refresh_tokens.json"
def _get_refresh_token(token_id: str) -> Optional[RefreshTokenTable]:
"""Get a refresh token from the database by token_id"""
with Session(engine) as session:
statement = select(RefreshTokenTable).where(RefreshTokenTable.token_id == token_id)
return session.exec(statement).first()
def _load_refresh_tokens() -> Dict[str, dict]:
"""Load refresh tokens from file"""
import json
try:
if os.path.exists(REFRESH_TOKENS_FILE):
with open(REFRESH_TOKENS_FILE, "r", encoding="utf-8") as f:
return json.load(f)
except Exception as e:
logger.error(f"Error loading refresh tokens: {e}")
return {}
def _save_refresh_token(token: RefreshTokenTable):
"""Save or update a refresh token in the database"""
with Session(engine) as session:
session.add(token)
session.commit()
def _save_refresh_tokens(tokens: Dict[str, dict]):
"""Save refresh tokens to file"""
import json
try:
os.makedirs(os.path.dirname(REFRESH_TOKENS_FILE), exist_ok=True)
with open(REFRESH_TOKENS_FILE, "w", encoding="utf-8") as f:
json.dump(tokens, f, indent=2, ensure_ascii=False, default=str)
except Exception as e:
logger.error(f"Error saving refresh tokens: {e}")
def _revoke_refresh_token_db(token_id: str) -> bool:
"""Revoke a refresh token in the database"""
with Session(engine) as session:
statement = select(RefreshTokenTable).where(RefreshTokenTable.token_id == token_id)
db_token = session.exec(statement).first()
if not db_token:
return False
db_token.revoked = True
db_token.revoked_at = datetime.now()
session.add(db_token)
session.commit()
return True
def _get_jwt_config() -> dict:
@@ -267,15 +264,15 @@ def create_access_refresh_tokens(data: dict) -> tuple[str, str]:
refresh_data, jwt_config["SECRET_KEY"], algorithm=jwt_config["ALGORITHM"]
)
# Store refresh token mapping
refresh_tokens = _load_refresh_tokens()
refresh_tokens[token_id] = {
"username": data["sub"],
"token_id": token_id,
"created_at": datetime.now().isoformat(),
"expires_at": refresh_expire.isoformat(),
}
_save_refresh_tokens(refresh_tokens)
# Store refresh token in database
db_token = RefreshTokenTable(
token_id=token_id,
username=data["sub"],
created_at=datetime.now(),
expires_at=refresh_expire,
revoked=False,
)
_save_refresh_token(db_token)
return access_token, refresh_token
@@ -305,15 +302,18 @@ def verify_refresh_token(token: str) -> Optional[str]:
if not username or not token_id:
return None
# Check if token exists in storage
refresh_tokens = _load_refresh_tokens()
stored_token = refresh_tokens.get(token_id)
# Check if token exists in database
stored_token = _get_refresh_token(token_id)
if not stored_token:
return None
# Verify token hasn't been revoked or expired
if stored_token.get("revoked"):
if stored_token.revoked:
return None
# Also check expiration in database
if stored_token.expires_at and stored_token.expires_at < datetime.now():
return None
return username
@@ -341,14 +341,7 @@ def revoke_refresh_token(token: str) -> bool:
if not token_id:
return False
refresh_tokens = _load_refresh_tokens()
if token_id in refresh_tokens:
refresh_tokens[token_id]["revoked"] = True
refresh_tokens[token_id]["revoked_at"] = datetime.now().isoformat()
_save_refresh_tokens(refresh_tokens)
return True
return False
return _revoke_refresh_token_db(token_id)
except JWTError:
return False
app/database.py
+1 -1
View File
@@ -18,7 +18,7 @@ engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
def create_db_and_tables():
"""Create the database and tables based on the models"""
# CRITICAL: Import ALL models here to ensure they are registered with SQLModel.metadata
from app.models.auth import UserTable
from app.models.auth import UserTable, RefreshTokenTable
from app.models.watchlist import WatchlistItemTable, WatchlistSettingsTable
from app.models.favorites import FavoriteTable
from app.models.sonarr import SonarrMappingTable, SonarrConfigTable
app/downloaders/__init__.py
-1
View File
@@ -17,7 +17,6 @@ from .anime_sites import (
BaseAnimeSite,
get_anime_site,
AnimeSamaDownloader,
NekoSamaDownloader,
AnimeUltimeDownloader,
VostfreeDownloader
)
app/downloaders/anime_sites/__init__.py
-3
View File
@@ -2,7 +2,6 @@
from .base import BaseAnimeSite
# Import all anime site downloaders
from .animesama import AnimeSamaDownloader
from .nekosama import NekoSamaDownloader
from .animeultime import AnimeUltimeDownloader
from .vostfree import VostfreeDownloader
from .frenchmanga import FrenchMangaDownloader
@@ -10,7 +9,6 @@ from .frenchmanga import FrenchMangaDownloader
__all__ = [
"BaseAnimeSite",
"AnimeSamaDownloader",
"NekoSamaDownloader",
"AnimeUltimeDownloader",
"VostfreeDownloader",
"FrenchMangaDownloader",
@@ -22,7 +20,6 @@ def get_anime_site(url: str) -> BaseAnimeSite:
sites = [
AnimeSamaDownloader(),
AnimeUltimeDownloader(),
NekoSamaDownloader(),
VostfreeDownloader(),
FrenchMangaDownloader(),
]
app/downloaders/anime_sites/animesama.py
+10 -6
View File
@@ -490,15 +490,16 @@ class AnimeSamaDownloader(BaseAnimeSite):
part.replace("saison", "").replace("Saison", "")
)
break
except:
pass
except Exception:
logger.debug("Could not parse season number from URL part")
episode = "01"
if season_num:
return f"{anime_name} - S{season_num} - Episode {episode}.mp4"
else:
return f"{anime_name} - Episode {episode}.mp4"
except:
except Exception:
logger.debug("Could not generate filename, using default")
return "Anime - Episode 01.Mp4"
def _generate_anime_name(self, anime_url: str) -> str:
@@ -511,7 +512,8 @@ class AnimeSamaDownloader(BaseAnimeSite):
return parts[i + 1].replace("-", " ").title()
# Fallback
return "Anime"
except:
except Exception:
logger.debug("Could not extract anime name from URL")
return "Anime"
def _extract_season_number(self, anime_url: str) -> int | None:
@@ -522,7 +524,8 @@ class AnimeSamaDownloader(BaseAnimeSite):
if "saison" in part.lower():
return int(part.replace("saison", "").replace("Saison", ""))
return None
except:
except Exception:
logger.debug("Could not extract season number from URL")
return None
async def _extract_from_lpayer(
@@ -744,7 +747,8 @@ class AnimeSamaDownloader(BaseAnimeSite):
if match:
return match.group(1)
except:
except Exception:
logger.debug("Could not extract video URL from scripts")
pass
return None
app/downloaders/anime_sites/nekosama.py
-317
View File
@@ -1,317 +0,0 @@
from .base import BaseAnimeSite
from bs4 import BeautifulSoup
import re
from typing import Optional
from urllib.parse import urljoin
class NekoSamaDownloader(BaseAnimeSite):
"""Downloader for neko-sama.org (anime streaming via Gupy)
NOTE: neko-sama.org now redirects to Gupy, which is a legal streaming search engine.
It does NOT host video content - it provides metadata about where to watch legally.
This provider can search and get metadata but cannot provide direct download links.
"""
BASE_DOMAINS = [
"neko-sama.org",
"www.neko-sama.org",
"neko-sama.fr",
"nekosama.fr",
"www.gupy.fr",
"gupy.fr",
]
def __init__(self):
super().__init__()
self.id = "neko-sama"
def can_handle(self, url: str) -> bool:
return any(domain in url.lower() for domain in self.BASE_DOMAINS)
async def get_download_link(
self, url: str, target_filename: Optional[str] = None
) -> tuple[str, str]:
"""
Extract download link from neko-sama URL.
NOTE: neko-sama.org/Gupy is a legal streaming search engine, NOT a video host.
This returns streaming platform information instead of direct video links.
"""
try:
# Check if this is a Gupy URL
if "gupy.fr" in url or "neko-sama.org" in url:
response = await self.client.get(url, follow_redirects=True)
soup = BeautifulSoup(response.text, "lxml")
# Look for streaming platform links
streaming_links = []
for link in soup.find_all("a", href=True):
href = link.get("href", "")
if "/out/" in href:
text = link.get_text(strip=True)
if text and "Regarder" in text:
streaming_links.append(f"{text}: {href}")
if streaming_links:
title_elem = soup.find("h1") or soup.find("title")
title = (
title_elem.get_text(strip=True).split("|")[0].strip()
if title_elem
else "Unknown"
)
info = "Available streaming platforms:\n" + "\n".join(
streaming_links[:5]
)
filename = target_filename or f"{title}_streaming_info.txt"
return info, filename
raise Exception(
"No streaming links found - Gupy is a legal streaming search, not a video host"
)
# Legacy: try original method for other URLs
response = await self.client.get(url, follow_redirects=True)
soup = BeautifulSoup(response.text, "lxml")
# Method 1: Look for iframes with video
iframes = soup.find_all("iframe")
for iframe in iframes:
src = iframe.get("src", "")
if src and any(p in src for p in ["video", "player", "stream"]):
if not src.startswith("http"):
src = urljoin(str(response.url), src)
filename = self._generate_filename(str(response.url))
return src, filename
# Method 2: Look for video tags
videos = soup.find_all("video")
for video in videos:
src = video.get("src") or video.get("data-src")
if src:
filename = self._generate_filename(str(response.url))
return src, filename
sources = video.find_all("source")
for source in sources:
src = source.get("src", "")
if src:
filename = self._generate_filename(str(response.url))
return src, filename
# Method 3: Look in scripts
scripts = soup.find_all("script")
for script in scripts:
if script.string:
patterns = [
r'(https?://[^"\'>\s]+\.(?:mp4|m3u8)(?:\?[^"\'>\s]*)?)',
r'"url":"([^"]+)"',
r'"video":"([^"]+)"',
]
for pattern in patterns:
matches = re.findall(pattern, script.string)
for match in matches:
match = match.replace("\\/", "/")
if any(ext in match for ext in ["mp4", "m3u8"]):
filename = self._generate_filename(str(response.url))
return match, filename
raise Exception(
"Could not find video link - Neko-Sama/Gupy does not host video content"
)
except Exception as e:
raise Exception(f"Error extracting NekoSama link: {str(e)}")
def _generate_filename(self, url: str) -> str:
parts = url.split("/")
anime_name = "anime"
episode = "1"
for i, part in enumerate(parts):
if "episode" in part.lower():
match = re.search(r"episode[-\s]*(\d+)", part, re.I)
if match:
episode = match.group(1)
filename = f"{anime_name} - Episode {episode}.mp4"
return filename.title()
async def get_episodes(self, anime_url: str, lang: str = "vostfr") -> list[dict]:
"""Get list of episodes for an anime."""
try:
response = await self.client.get(anime_url)
soup = BeautifulSoup(response.text, "lxml")
episodes = []
# Try to find episode links
episode_links = soup.find_all("a", href=re.compile(r"episode"))
for link in episode_links:
href = link.get("href", "")
match = re.search(r"episode[-\s]*(\d+)", href, re.I)
if match:
episode_num = match.group(1)
if not href.startswith("http"):
href = urljoin(anime_url, href)
episodes.append({"episode": episode_num, "url": href})
# Deduplicate and sort
seen = set()
unique_episodes = []
for ep in episodes:
if ep["episode"] not in seen:
seen.add(ep["episode"])
unique_episodes.append(ep)
unique_episodes.sort(key=lambda x: int(x["episode"]))
return unique_episodes
except Exception as e:
return []
async def get_anime_metadata(self, anime_url: str) -> dict:
"""Extract rich metadata from anime page."""
try:
print(f"[NEKO-SAMA] Extracting metadata from: {anime_url}")
response = await self.client.get(anime_url)
soup = BeautifulSoup(response.text, "lxml")
metadata = {
"synopsis": None,
"genres": [],
"rating": None,
"release_year": None,
"studio": None,
"poster_image": None,
"banner_image": None,
"total_episodes": None,
"status": None,
"alternative_titles": [],
}
# Extract title and year from h1
title_elem = soup.find("h1")
if title_elem:
title_text = title_elem.get_text(strip=True)
# Extract year from title like "Naruto (2002)"
year_match = re.search(r"\((\d{4})\)", title_text)
if year_match:
metadata["release_year"] = int(year_match.group(1))
# Extract synopsis - Gupy shows it as paragraphs
synopsis_elem = soup.find("p")
if synopsis_elem:
text = synopsis_elem.get_text(strip=True)
if len(text) > 50:
metadata["synopsis"] = text
# Extract genres from meta tags or links
genre_links = soup.find_all("a", href=re.compile(r"serie-|genre|tag"))
if genre_links:
genres = []
for link in genre_links[:5]:
text = link.get_text(strip=True)
if text and "/" not in text and len(text) < 30:
genres.append(text)
metadata["genres"] = genres
# Extract rating from percentage
rating_elem = soup.find(string=re.compile(r"\d+(\.\d+)?%"))
if rating_elem:
match = re.search(r"(\d+(\.\d+)?)%", rating_elem)
if match:
rating = float(match.group(1)) / 10
metadata["rating"] = f"{rating:.1f}/10"
# Extract poster image
poster_elem = soup.find("img", src=re.compile(r"poster|poster"))
if poster_elem:
metadata["poster_image"] = poster_elem.get("src")
# Extract episode count from page text
page_text = soup.get_text()
ep_match = re.search(r"(\d+)\s*episodes?", page_text, re.I)
if ep_match:
metadata["total_episodes"] = int(ep_match.group(1))
# Extract studio/director
director_elem = soup.find("a", href=re.compile(r"person|réalisé"))
if director_elem:
metadata["studio"] = director_elem.get_text(strip=True)
print(f"[NEKO-SAMA] Extracted metadata: {metadata}")
return metadata
except Exception as e:
print(f"[NEKO-SAMA] Error extracting metadata: {e}")
return {}
async def search_anime(
self, query: str, lang: str = "vostfr", include_metadata: bool = False
) -> list[dict]:
"""Search for anime on neko-sama (uses Gupy backend)."""
try:
import time
from html import unescape
start = time.time()
print(f"[NEKO-SAMA] Searching for '{query}' ({lang})...")
# Neko-Sama now uses Gupy - try the direct URL pattern
search_slug = query.lower().replace(" ", "-")
search_urls = [
f"https://www.gupy.fr/series/{search_slug}/",
f"https://neko-sama.org/series/{search_slug}/",
]
results = []
for search_url in search_urls:
response = await self.client.get(search_url, follow_redirects=True)
print(f"[NEKO-SAMA] Tried {search_url} -> {response.status_code}")
if response.status_code == 200:
final_url = str(response.url)
print(f"[NEKO-SAMA] Found anime at {final_url}")
# Extract title from page
soup = BeautifulSoup(response.text, "lxml")
title_elem = soup.find("h1") or soup.find("title")
title = (
unescape(title_elem.get_text(strip=True))
if title_elem
else query
)
# Clean up title
title = title.split("|")[0].split("-")[0].strip()
result = {
"title": title,
"url": final_url,
"cover_image": None,
"type": "direct",
"metadata": None,
}
# Try to get poster
poster = soup.find("img", src=re.compile(r"poster"))
if poster:
result["cover_image"] = poster.get("src")
if include_metadata:
metadata = await self.get_anime_metadata(final_url)
result["metadata"] = metadata
results.append(result)
break
elapsed = time.time() - start
print(
f"[NEKO-SAMA] Search completed in {elapsed:.2f}s, found {len(results)} results"
)
return results
except Exception as e:
print(f"[NEKO-SAMA] Error: {str(e)}")
return []
app/downloaders/video_players/doodstream.py
+1 -1
View File
@@ -68,7 +68,7 @@ class DoodStreamDownloader(BaseVideoPlayer):
fname = self._extract_filename_from_headers(head_resp.headers)
if fname:
filename = fname
except:
except Exception:
pass
return download_url, filename
app/downloaders/video_players/lpayer.py
+2 -2
View File
@@ -102,7 +102,7 @@ class LpayerDownloader(BaseVideoPlayer):
try:
await page.mouse.click(640, 360)
await asyncio.sleep(3)
except:
except Exception:
pass
# Try JavaScript extraction to find video URLs in DOM
@@ -235,7 +235,7 @@ class LpayerDownloader(BaseVideoPlayer):
if browser:
try:
await browser.close()
except:
except Exception:
pass
"""Extract video URL using Playwright to render JavaScript"""
try:
app/downloaders/video_players/oneupload.py
+1 -1
View File
@@ -124,7 +124,7 @@ class OneuploadDownloader(BaseVideoPlayer):
await element.click()
await asyncio.sleep(2)
break
except:
except Exception:
continue
except Exception as e:
print(f"[ONEUPLOAD] Play button interaction: {e}")
app/downloaders/video_players/rapidfile.py
+1 -1
View File
@@ -62,7 +62,7 @@ class RapidFileDownloader(BaseVideoPlayer):
filename = fname
else:
filename = download_url.split('/')[-1] or "rapidfile_download"
except:
except Exception:
filename = download_url.split('/')[-1] or "rapidfile_download"
return download_url, filename
app/downloaders/video_players/smoothpre.py
+1 -1
View File
@@ -118,7 +118,7 @@ class SmoothpreDownloader(BaseVideoPlayer):
await element.click()
await asyncio.sleep(2)
break
except:
except Exception:
continue
except Exception as e:
print(f"[SMOOTHPRE] Play button interaction: {e}")
app/downloaders/video_players/unfichier.py
+1 -1
View File
@@ -42,7 +42,7 @@ class UnFichierDownloader(BaseVideoPlayer):
if not filename:
filename = href.split('/')[-1] or "downloaded_file"
return href, filename
except:
except Exception:
continue
raise Exception("Could not find download link on page")
app/downloaders/video_players/vidmoly.py
+1 -1
View File
@@ -177,7 +177,7 @@ class VidMolyDownloader(BaseVideoPlayer):
await element.click()
await asyncio.sleep(3)
break
except:
except Exception:
continue
except Exception as e:
print(f"[VIDMOLY] Play button interaction: {e}")
app/models/auth.py
+19
View File
@@ -62,5 +62,24 @@ class UserInDB(User):
"""Schema for user stored in database (with hashed password)"""
hashed_password: str
class RefreshTokenTable(SQLModel, table=True):
"""Database table for refresh tokens"""
__tablename__ = "refresh_tokens"
id: str = Field(
default_factory=lambda: str(uuid.uuid4()),
primary_key=True,
index=True,
nullable=False
)
token_id: str = Field(index=True, unique=True)
username: str = Field(index=True)
created_at: datetime = Field(default_factory=datetime.now)
expires_at: Optional[datetime] = None
revoked: bool = Field(default=False)
revoked_at: Optional[datetime] = None
# Import WatchlistItemTable here to resolve SQLModel Relationship mappings
from .watchlist import WatchlistItemTable
app/models/settings.py
+1 -1
View File
@@ -32,7 +32,7 @@ class AppSettingsBase(SQLModel):
def disabled_providers(self) -> List[str]:
try:
return json.loads(self.disabled_providers_json or "[]")
except:
except json.JSONDecodeError:
return []
@disabled_providers.setter
app/models/sonarr.py
+1 -1
View File
@@ -160,7 +160,7 @@ class SonarrMapping(BaseModel):
"""Mapping between Sonarr series and anime providers (API model)"""
sonarr_series_id: int
sonarr_title: str
anime_provider: str # 'anime-sama', 'neko-sama', etc.
anime_provider: str # 'anime-sama', 'anime-ultime', 'vostfree', 'french-manga', etc.
anime_url: str
anime_title: str
lang: str = "vostfr"
app/providers.py
-7
View File
@@ -25,13 +25,6 @@ ANIME_PROVIDERS = {
"icon": "▶️",
"color": "#00ff88",
},
"neko-sama": {
"name": "Neko-Sama",
"domains": ["neko-sama.fr", "nekosama.fr", "www.neko-sama.fr"],
"url_pattern": "https://neko-sama.fr/anime/{slug}",
"icon": "🐱",
"color": "#ff6b6b",
},
"vostfree": {
"name": "Vostfree",
"domains": ["vostfree.tv", "www.vostfree.tv"],
app/providers_manager.py
+15 -4
View File
@@ -10,7 +10,6 @@ from datetime import datetime
from app.downloaders.generic_scraper import GenericScraper
from app.downloaders.anime_sites import (
AnimeSamaDownloader,
NekoSamaDownloader,
AnimeUltimeDownloader,
VostfreeDownloader,
FrenchMangaDownloader,
@@ -58,7 +57,6 @@ class ProvidersManager:
"""Load hardcoded Python providers"""
provider_classes = [
("anime-sama", AnimeSamaDownloader, ANIME_PROVIDERS),
("neko-sama", NekoSamaDownloader, ANIME_PROVIDERS),
("anime-ultime", AnimeUltimeDownloader, ANIME_PROVIDERS),
("vostfree", VostfreeDownloader, ANIME_PROVIDERS),
("french-manga", FrenchMangaDownloader, ANIME_PROVIDERS),
@@ -130,10 +128,23 @@ class ProvidersManager:
return 200 <= response.status_code < 400
elif hasattr(scraper, "search_anime"):
results = await scraper.search_anime("One Piece", lang="vostfr")
return len(results) > 0
# Validate that results actually match the query
if not results:
return False
for r in results:
title = (r.get("title") or "").lower()
if "one" in title or "piece" in title:
return True
return False
elif hasattr(scraper, "search"):
results = await scraper.search("One Piece")
return len(results) > 0
if not results:
return False
for r in results:
title = (r.get("title") or "").lower()
if "one" in title or "piece" in title:
return True
return False
return False
except Exception as e:
logger.error(
app/routers/router_anime.py
+10 -8
View File
@@ -29,7 +29,6 @@ from app.download_manager import DownloadManager
from app.downloaders import (
AnimeSamaDownloader,
AnimeUltimeDownloader,
NekoSamaDownloader,
VostfreeDownloader,
ZoneTelechargementDownloader,
get_downloader,
@@ -59,12 +58,10 @@ async def get_providers_health():
@router.post("/providers/health/check")
async def trigger_providers_health_check(background_tasks: BackgroundTasks):
"""Trigger a manual health check of all providers in the background"""
from app.auto_download_scheduler import auto_download_scheduler
background_tasks.add_task(auto_download_scheduler.trigger_health_check_now)
return {"status": "Health check triggered in background"}
async def trigger_providers_health_check():
"""Trigger a manual health check of all providers"""
await providers_manager.check_all_health()
return {"status": "ok", "providers": providers_manager.get_all_status()}
def get_download_manager() -> DownloadManager:
@@ -136,7 +133,6 @@ async def search_anime_unified(
# Legacy providers (already included in providers_manager, but keep for fallback)
legacy_downloaders = {
"anime-ultime": AnimeUltimeDownloader(),
"neko-sama": NekoSamaDownloader(),
"vostfree": VostfreeDownloader(),
}
for pid, dl in legacy_downloaders.items():
@@ -196,6 +192,12 @@ async def search_anime_unified(
else:
item_dict["_relevance_boost"] = 0.3
# Filter out results with very low relevance
MIN_RELEVANCE_THRESHOLD = 0.5
if item_dict["_relevance_boost"] < MIN_RELEVANCE_THRESHOLD:
logger.debug(f"Filtered low-relevance result '{title}' for query '{q}' (score: {item_dict['_relevance_boost']})")
continue
results[pid].append(item_dict)
# Prepare enrichment task for top 15 results per provider
app/sonarr_handler.py
+1 -2
View File
@@ -17,7 +17,7 @@ from app.models.sonarr import (
SonarrDownloadRequest
)
from app.models import DownloadRequest
from app.downloaders import get_downloader, AnimeSamaDownloader, NekoSamaDownloader, AnimeUltimeDownloader, VostfreeDownloader
from app.downloaders import get_downloader, AnimeSamaDownloader, AnimeUltimeDownloader, VostfreeDownloader
# Configure logging
logger = logging.getLogger(__name__)
@@ -205,7 +205,6 @@ class SonarrHandler:
"""Get downloader instance for provider"""
providers = {
"anime-sama": AnimeSamaDownloader(),
"neko-sama": NekoSamaDownloader(),
"anime-ultime": AnimeUltimeDownloader(),
"vostfree": VostfreeDownloader()
}