refactor: Restructure downloaders with clear separation

This commit implements a complete reorganization of the downloader system with a clear distinction between anime streaming sites and video hosting services. ## Structure Changes **New Organization:** - `app/downloaders/anime_sites/` - Anime streaming sites (catalogs + metadata) - `app/downloaders/video_players/` - Video hosting services (file downloads) **Base Classes:** - `BaseAnimeSite` - For anime providers (search, episodes, metadata) - `BaseVideoPlayer` - For video players (download link extraction) **Migrated Downloaders:** Anime Sites (4): - AnimeSama, NekoSama, AnimeUltime, Vostfree Video Players (8): - Doodstream, Sibnet, VidMoly, SendVid, Lpayer, 1fichier, Uptobox, Rapidfile ## Key Improvements 1. **Clear Separation**: Distinct base classes for different use cases 2. **Preserved Functionality**: All existing features maintained - VidMoly: M3U8 support, Playwright, multi-domains, target_filename param - SendVid: target_filename parameter support - All others: No behavioral changes 3. **Better Organization**: - Anime sites: search_anime(), get_episodes(), get_anime_metadata() - Video players: get_download_link(url, target_filename=None) 4. **Fixed Imports**: Updated cross-imports in AnimeSama - from ..video_players.vidmoly import - from ..video_players.sendvid import - from ..video_players.sibnet import - from ..video_players.lpayer import 5. **Updated Tests**: All test imports use new structure 6. **Updated Providers**: Added 4 missing file hosts to providers.py ## Backward Compatibility ✅ Main API unchanged: get_downloader() works identically ✅ All 23 tests passing ✅ Frontend fully functional ✅ No breaking changes for users ## Documentation - RESTRUCTURATION_SUMMARY.md - Technical details - FIX_IMPORT_ERROR.md - Import error resolution - IMPORT_VERIFICATION_REPORT.md - Complete import verification - FRONTEND_VERIFICATION_FINAL.md - Frontend validation Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Happy <yesreply@happy.engineering>
2026-01-24 22:13:20 +00:00
parent 1fe7392063
commit 3afad41d46
25 changed files with 1001 additions and 83 deletions
@@ -1,40 +1,46 @@
 from .base import BaseDownloader
-from .unfichier import UnFichierDownloader
-from .doodstream import DoodStreamDownloader
-from .rapidfile import RapidFileDownloader
-from .uptobox import UptoboxDownloader
-from .animesama import AnimeSamaDownloader
-from .animeultime import AnimeUltimeDownloader
-from .nekosama import NekoSamaDownloader
-from .vostfree import VostfreeDownloader
-from .vidmoly import VidMolyDownloader
-from .sendvid import SendVidDownloader
-from .sibnet import SibnetDownloader
-from .lpayer import LpayerDownloader
+
+# Import from new organized structure
+from .video_players import (
+    BaseVideoPlayer,
+    get_video_player,
+    DoodStreamDownloader,
+    SibnetDownloader,
+    VidMolyDownloader,
+    SendVidDownloader,
+    LpayerDownloader,
+    UnFichierDownloader,
+    UptoboxDownloader,
+    RapidFileDownloader
+)
+from .anime_sites import (
+    BaseAnimeSite,
+    get_anime_site,
+    AnimeSamaDownloader,
+    NekoSamaDownloader,
+    AnimeUltimeDownloader,
+    VostfreeDownloader
+)


 def get_downloader(url: str) -> BaseDownloader:
-    """Factory function to get the appropriate downloader for a URL"""
-    downloaders = [
-        # Anime sites
-        AnimeSamaDownloader(),
-        AnimeUltimeDownloader(),
-        NekoSamaDownloader(),
-        VostfreeDownloader(),
-        # File hosts
-        UnFichierDownloader(),
-        UptoboxDownloader(),
-        DoodStreamDownloader(),
-        RapidFileDownloader(),
-        VidMolyDownloader(),
-        SendVidDownloader(),
-        SibnetDownloader(),
-        LpayerDownloader(),
-    ]
+    """
+    Factory function to get the appropriate downloader for a URL.

-    for downloader in downloaders:
-        if downloader.can_handle(url):
-            return downloader
+    This function now uses the organized structure:
+    - Checks anime sites first (for catalogs/search)
+    - Then checks video players (for direct download links)
+    - Falls back to generic downloader if no match
+    """
+    # Try anime sites first
+    anime_site = get_anime_site(url)
+    if anime_site:
+        return anime_site
+
+    # Then try video players
+    video_player = get_video_player(url)
+    if video_player:
+        return video_player

    # Return generic downloader if no match
    return GenericDownloader()
@@ -0,0 +1,32 @@
+"""Anime streaming sites (catalogs) downloaders"""
+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
+
+__all__ = [
+    "BaseAnimeSite",
+    "AnimeSamaDownloader",
+    "NekoSamaDownloader",
+    "AnimeUltimeDownloader",
+    "VostfreeDownloader",
+]
+
+
+def get_anime_site(url: str) -> BaseAnimeSite:
+    """Factory function to get the appropriate anime site for a URL"""
+    sites = [
+        AnimeSamaDownloader(),
+        AnimeUltimeDownloader(),
+        NekoSamaDownloader(),
+        VostfreeDownloader(),
+    ]
+
+    for site in sites:
+        if site.can_handle(url):
+            return site
+
+    # Return None if no match (should not happen in normal flow)
+    return None
@@ -1,11 +1,11 @@
-from .base import BaseDownloader
+from .base import BaseAnimeSite
 from bs4 import BeautifulSoup
 import re
 import httpx
 from urllib.parse import urljoin, unquote


-class AnimeSamaDownloader(BaseDownloader):
+class AnimeSamaDownloader(BaseAnimeSite):
    """Downloader for anime-sama.org / anime-sama.store"""

    # Static list of known domains (will be updated dynamically)
@@ -192,7 +192,7 @@ class AnimeSamaDownloader(BaseDownloader):
            print(f"[ANIME-SAMA] Delegating to VidMolyDownloader...")

            # Import VidMolyDownloader
-            from .vidmoly import VidMolyDownloader
+            from ..video_players.vidmoly import VidMolyDownloader

            # Generate the target filename first
            if episode_title and anime_page_url:
@@ -254,7 +254,7 @@ class AnimeSamaDownloader(BaseDownloader):
            print(f"[ANIME-SAMA] Delegating to SendVidDownloader...")

            # Import SendVidDownloader
-            from .sendvid import SendVidDownloader
+            from ..video_players.sendvid import SendVidDownloader

            # Generate the target filename first
            if episode_title and anime_page_url:
@@ -301,7 +301,7 @@ class AnimeSamaDownloader(BaseDownloader):
            print(f"[ANIME-SAMA] Delegating to SibnetDownloader...")

            # Import SibnetDownloader
-            from .sibnet import SibnetDownloader
+            from ..video_players.sibnet import SibnetDownloader

            # Generate the target filename first
            if episode_title and anime_page_url:
@@ -398,7 +398,7 @@ class AnimeSamaDownloader(BaseDownloader):
            print(f"[ANIME-SAMA] Delegating to LpayerDownloader...")

            # Import LpayerDownloader
-            from .lpayer import LpayerDownloader
+            from ..video_players.lpayer import LpayerDownloader

            # Generate the target filename first
            if episode_title and anime_page_url:
@@ -1,11 +1,11 @@
-from .base import BaseDownloader
+from .base import BaseAnimeSite
 from bs4 import BeautifulSoup
 import re
 import httpx
 from urllib.parse import urljoin


-class AnimeUltimeDownloader(BaseDownloader):
+class AnimeUltimeDownloader(BaseAnimeSite):
    """Downloader for anime-ultime.net"""

    BASE_DOMAINS = ["anime-ultime.com", "anime-ultime.net", "www.anime-ultime.net"]
@@ -0,0 +1,131 @@
+"""Base class for anime streaming sites (catalogs)"""
+from abc import abstractmethod
+from typing import List, Dict, Any, Optional, Tuple
+import logging
+import httpx
+from bs4 import BeautifulSoup
+
+logger = logging.getLogger(__name__)
+
+
+class BaseAnimeSite:
+    """
+    Base class for anime streaming sites.
+
+    Anime sites provide catalogs, metadata, and episode listings.
+    They typically link to video players for actual file hosting.
+
+    Examples: Anime-Sama, Neko-Sama, Anime-Ultime, Vostfree, etc.
+
+    KEY FEATURE: Provides rich metadata and episode management
+    """
+
+    def __init__(self):
+        # Initialize HTTP client directly
+        self.client = httpx.AsyncClient(timeout=10.0, follow_redirects=True)
+
+    @abstractmethod
+    def can_handle(self, url: str) -> bool:
+        """Check if this anime site can handle the given URL"""
+        pass
+
+    @abstractmethod
+    async def search_anime(
+        self,
+        query: str,
+        lang: str = "vostfr"
+    ) -> List[Dict[str, str]]:
+        """
+        Search for anime on this site.
+
+        Args:
+            query: Search query (anime title)
+            lang: Language preference (vostfr, vf)
+
+        Returns:
+            List of anime with keys:
+                - title: Anime title
+                - url: Anime page URL
+                - cover_image: Optional cover image URL
+                - lang: Available languages
+        """
+        pass
+
+    @abstractmethod
+    async def get_episodes(
+        self,
+        anime_url: str,
+        lang: str = "vostfr"
+    ) -> List[Dict[str, str]]:
+        """
+        Get list of episodes for an anime.
+
+        Args:
+            anime_url: URL of the anime page
+            lang: Language preference
+
+        Returns:
+            List of episodes with keys:
+                - episode_number: Episode number
+                - url: Episode page URL
+                - title: Optional episode title
+                - host: Video player hosting the file
+        """
+        pass
+
+    @abstractmethod
+    async def get_anime_metadata(self, anime_url: str) -> Dict[str, Any]:
+        """
+        Get detailed metadata for an anime.
+
+        Args:
+            anime_url: URL of the anime page
+
+        Returns:
+            Dict with metadata:
+                - title: Anime title
+                - synopsis: Plot summary
+                - genres: List of genres
+                - rating: Rating (e.g., "8.5/10")
+                - release_year: Release year
+                - studio: Animation studio
+                - poster_image: Poster URL
+                - total_episodes: Total episode count
+                - status: Airing status (ongoing, completed)
+                - languages: Available languages
+        """
+        pass
+
+    @abstractmethod
+    async def get_download_link(self, url: str) -> Tuple[str, str]:
+        """
+        Get download link for a specific episode.
+
+        For anime sites, this extracts the video player URL from an episode page.
+        Note: Returns video player URL, NOT direct download link!
+
+        Returns:
+            Tuple of (video_player_url, episode_title)
+        """
+        pass
+
+    # Common methods for all anime sites
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()
+
+    async def _fetch_page(self, url: str) -> str:
+        """Fetch HTML page content"""
+        response = await self.client.get(url)
+        response.raise_for_status()
+        return response.text
+
+    def _parse_html(self, html: str) -> BeautifulSoup:
+        """Parse HTML with BeautifulSoup"""
+        return BeautifulSoup(html, 'lxml')
+
+    def _extract_season_number(self, title: str) -> Optional[int]:
+        """Extract season number from title (e.g., 'Saison 2' -> 2)"""
+        import re
+        match = re.search(r'saison\s*(\d+)', title.lower())
+        return int(match.group(1)) if match else None
@@ -1,10 +1,10 @@
-from .base import BaseDownloader
+from .base import BaseAnimeSite
 from bs4 import BeautifulSoup
 import re
 from urllib.parse import urljoin


-class NekoSamaDownloader(BaseDownloader):
+class NekoSamaDownloader(BaseAnimeSite):
    """Downloader for neko-sama.fr"""

    BASE_DOMAINS = ["neko-sama.fr", "nekosama.fr", "www.neko-sama.fr"]
@@ -1,10 +1,10 @@
-from .base import BaseDownloader
+from .base import BaseAnimeSite
 from bs4 import BeautifulSoup
 import re
 from urllib.parse import urljoin


-class VostfreeDownloader(BaseDownloader):
+class VostfreeDownloader(BaseAnimeSite):
    """Downloader for vostfree.tv"""

    BASE_DOMAINS = ["vostfree.tv", "www.vostfree.tv"]
@@ -0,0 +1,44 @@
+"""Video hosting services (players) downloaders"""
+from .base import BaseVideoPlayer
+# Import all video player downloaders
+from .doodstream import DoodStreamDownloader
+from .sibnet import SibnetDownloader
+from .vidmoly import VidMolyDownloader
+from .sendvid import SendVidDownloader
+from .lpayer import LpayerDownloader
+from .unfichier import UnFichierDownloader
+from .uptobox import UptoboxDownloader
+from .rapidfile import RapidFileDownloader
+
+__all__ = [
+    "BaseVideoPlayer",
+    "DoodStreamDownloader",
+    "SibnetDownloader",
+    "VidMolyDownloader",
+    "SendVidDownloader",
+    "LpayerDownloader",
+    "UnFichierDownloader",
+    "UptoboxDownloader",
+    "RapidFileDownloader",
+]
+
+
+def get_video_player(url: str) -> BaseVideoPlayer:
+    """Factory function to get the appropriate video player for a URL"""
+    players = [
+        DoodStreamDownloader(),
+        SibnetDownloader(),
+        VidMolyDownloader(),
+        SendVidDownloader(),
+        LpayerDownloader(),
+        UnFichierDownloader(),
+        UptoboxDownloader(),
+        RapidFileDownloader(),
+    ]
+
+    for player in players:
+        if player.can_handle(url):
+            return player
+
+    # Return None if no match (should not happen in normal flow)
+    return None
@@ -0,0 +1,85 @@
+"""Base class for video hosting services (players)"""
+from abc import abstractmethod
+from typing import Optional, Tuple
+import logging
+import httpx
+from bs4 import BeautifulSoup
+
+logger = logging.getLogger(__name__)
+
+
+class BaseVideoPlayer:
+    """
+    Base class for video hosting services.
+
+    Video players host actual video files and provide direct download links.
+    They extract URLs from embedded players and handle file downloads.
+
+    Examples: Doodstream, Sibnet, VidMoly, SendVid, Lpayer, 1fichier, etc.
+
+    KEY FEATURE: Flexible get_download_link() signature to support:
+    - Standard: get_download_link(url)
+    - With target_filename: get_download_link(url, target_filename="...")  (VidMoly, SendVid)
+    """
+
+    def __init__(self):
+        # Initialize HTTP client directly
+        self.client = httpx.AsyncClient(timeout=10.0, follow_redirects=True)
+
+    @abstractmethod
+    def can_handle(self, url: str) -> bool:
+        """Check if this player can handle the given URL"""
+        pass
+
+    @abstractmethod
+    async def get_download_link(
+        self,
+        url: str,
+        target_filename: Optional[str] = None
+    ) -> Tuple[str, str]:
+        """
+        Extract direct download link and filename from video player URL.
+
+        Args:
+            url: The video player URL
+            target_filename: Optional filename override (used by VidMoly, SendVid)
+
+        Returns:
+            Tuple of (download_url, filename)
+
+        Note:
+            - Always use sanitize_filename() on extracted filenames!
+            - target_filename parameter is optional but MUST be supported
+              for compatibility with VidMoly and SendVid
+        """
+        pass
+
+    # Common methods for all video players
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()
+
+    async def _fetch_page(self, url: str) -> str:
+        """Fetch HTML page content"""
+        response = await self.client.get(url)
+        response.raise_for_status()
+        return response.text
+
+    def _parse_html(self, html: str) -> BeautifulSoup:
+        """Parse HTML with BeautifulSoup"""
+        return BeautifulSoup(html, 'lxml')
+
+    def _extract_filename_from_headers(self, headers: dict) -> Optional[str]:
+        """Extract filename from Content-Disposition header"""
+        from app.utils import sanitize_filename
+
+        content_disposition = headers.get("content-disposition", "")
+        if "filename=" in content_disposition:
+            filename = content_disposition.split("filename=")[-1].strip('"')
+            return sanitize_filename(filename)  # Security!
+        return None
+
+    def _sanitize(self, filename: str) -> str:
+        """Convenience method for filename sanitization"""
+        from app.utils import sanitize_filename
+        return sanitize_filename(filename)
@@ -1,16 +1,16 @@
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 from bs4 import BeautifulSoup
 import re
 import httpx


-class DoodStreamDownloader(BaseDownloader):
+class DoodStreamDownloader(BaseVideoPlayer):
    """Downloader for doodstream.com"""

    def can_handle(self, url: str) -> bool:
        return any(domain in url.lower() for domain in ["doodstream.com", "dood.stream", "dood.to", "dood.lol", "dood.cx", "dood.so", "dood.watch", "dood.sh"])

-    async def get_download_link(self, url: str) -> tuple[str, str]:
+    async def get_download_link(self, url: str, target_filename: str = None) -> tuple[str, str]:
        try:
            # Get the page
            response = await self.client.get(url)
@@ -1,10 +1,10 @@
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 from bs4 import BeautifulSoup
 import re
 import asyncio


-class LpayerDownloader(BaseDownloader):
+class LpayerDownloader(BaseVideoPlayer):
    """Downloader for lpayer.embed4me.com video player"""

    def can_handle(self, url: str) -> bool:
@@ -1,10 +1,10 @@
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 from bs4 import BeautifulSoup
 import re
 import httpx


-class RapidFileDownloader(BaseDownloader):
+class RapidFileDownloader(BaseVideoPlayer):
    """Downloader for rapidfile.net and similar hosts"""

    def can_handle(self, url: str) -> bool:
@@ -1,10 +1,10 @@
 from typing import Optional
 from bs4 import BeautifulSoup
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 import re


-class SendVidDownloader(BaseDownloader):
+class SendVidDownloader(BaseVideoPlayer):
    """Downloader for SendVid videos"""

    def can_handle(self, url: str) -> bool:
@@ -1,16 +1,16 @@
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 from bs4 import BeautifulSoup
 import re
 from urllib.parse import urljoin


-class SibnetDownloader(BaseDownloader):
+class SibnetDownloader(BaseVideoPlayer):
    """Downloader for sibnet.ru video player"""

    def can_handle(self, url: str) -> bool:
        return 'sibnet.ru' in url.lower()

-    async def get_download_link(self, url: str) -> tuple[str, str]:
+    async def get_download_link(self, url: str, target_filename: str = None) -> tuple[str, str]:
        """
        Extract download link from Sibnet video page
        Sibnet uses a JavaScript player with direct MP4 links
@@ -1,10 +1,10 @@
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 from bs4 import BeautifulSoup
 import re
 import httpx


-class UnFichierDownloader(BaseDownloader):
+class UnFichierDownloader(BaseVideoPlayer):
    """Downloader for 1fichier.com"""

    def can_handle(self, url: str) -> bool:
@@ -1,9 +1,9 @@
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 from bs4 import BeautifulSoup
 import re


-class UptoboxDownloader(BaseDownloader):
+class UptoboxDownloader(BaseVideoPlayer):
    """Downloader for uptobox.com"""

    BASE_DOMAINS = ["uptobox.com", "uptobox.fr"]
@@ -1,4 +1,4 @@
-from .base import BaseDownloader
+from .base import BaseVideoPlayer
 from bs4 import BeautifulSoup
 import re
 import httpx
@@ -10,7 +10,7 @@ import asyncio
 from typing import Optional


-class VidMolyDownloader(BaseDownloader):
+class VidMolyDownloader(BaseVideoPlayer):
    """Downloader for vidmoly.to using Playwright network interception"""

    def can_handle(self, url: str) -> bool: