fix: api manual scraping fixes

src/program/services/downloaders/models.py

@@ -47,18 +47,27 @@ class DebridFile(BaseModel):
     filesize: Optional[int] = Field(default=None)
 
     @classmethod
-    def create(cls, filename: str, filesize_bytes: int, filetype: Literal["movie", "episode"], file_id: Optional[int] = None) -> Optional["DebridFile"]:
+    def create(
+        cls,
+        filename: str,
+        filesize_bytes: int,
+        filetype: Literal["movie", "show", "season", "episode"],
+        file_id: Optional[int] = None,
+        limit_filesize: bool = True
+
+    ) -> Optional["DebridFile"]:
         """Factory method to validate and create a DebridFile"""
         if not any(filename.endswith(ext) for ext in VIDEO_EXTENSIONS) and not "sample" in filename.lower():
             return None
-
-        filesize_mb = filesize_bytes / 1_000_000
-        if filetype == "movie":
-            if not (FILESIZE_MOVIE_CONSTRAINT[0] <= filesize_mb <= FILESIZE_MOVIE_CONSTRAINT[1]):
-                return None
-        elif filetype == "episode":
-            if not (FILESIZE_EPISODE_CONSTRAINT[0] <= filesize_mb <= FILESIZE_EPISODE_CONSTRAINT[1]):
-                return None
+
+        if limit_filesize:
+            filesize_mb = filesize_bytes / 1_000_000
+            if filetype == "movie":
+                if not (FILESIZE_MOVIE_CONSTRAINT[0] <= filesize_mb <= FILESIZE_MOVIE_CONSTRAINT[1]):
+                    return None
+            elif filetype in ["show", "season", "episode"]:
+                if not (FILESIZE_EPISODE_CONSTRAINT[0] <= filesize_mb <= FILESIZE_EPISODE_CONSTRAINT[1]):
+                    return None
 
         return cls(filename=filename, filesize=filesize_bytes, file_id=file_id)
 

src/program/services/downloaders/shared.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Optional
+from typing import Optional, Union
 
 from RTN import ParsedData, parse
 
@@ -41,30 +41,34 @@ def get_instant_availability(self, infohash: str, item_type: str) -> Optional[To
         pass
 
     @abstractmethod
-    def add_torrent(self, infohash: str) -> int:
+    def add_torrent(self, infohash: str) -> Union[int, str]:
         """
         Add a torrent and return its information
 
         Args:
             infohash: The hash of the torrent to add
 
         Returns:
-            str: The ID of the added torrent
+            Union[int, str]: The ID of the added torrent
+
+        Notes:
+            The return type changes depending on the downloader
         """
         pass
 
     @abstractmethod
-    def select_files(self, request: list[int]) -> None:
+    def select_files(self, torrent_id: Union[int, str], file_ids: list[int]) -> None:
         """
         Select which files to download from the torrent
 
         Args:
-            request: File selection details including torrent ID and file IDs
+            torrent_id: ID of the torrent to select files for
+            file_ids: IDs of the files to select
         """
         pass
 
     @abstractmethod
-    def get_torrent_info(self, torrent_id: str) -> TorrentInfo:
+    def get_torrent_info(self, torrent_id: Union[int, str]) -> TorrentInfo:
         """
         Get information about a specific torrent using its ID
 
@@ -77,7 +81,7 @@ def get_torrent_info(self, torrent_id: str) -> TorrentInfo:
         pass
 
     @abstractmethod
-    def delete_torrent(self, torrent_id: str) -> None:
+    def delete_torrent(self, torrent_id: Union[int, str]) -> None:
         """
         Delete a torrent from the service
 

src/program/services/scrapers/mediafusion.py

@@ -66,6 +66,9 @@ def validate(self) -> bool:
         elif self.app_settings.downloaders.torbox.enabled:
             self.api_key = self.app_settings.downloaders.torbox.api_key
             self.downloader = "torbox"
+        elif self.app_settings.downloaders.all_debrid.enabled:
+            self.api_key = self.app_settings.downloaders.all_debrid.api_key
+            self.downloader = "alldebrid"
         else:
             logger.error("No downloader enabled, please enable at least one.")
             return False

src/routers/secure/scrape.py

@@ -19,6 +19,7 @@
 from program.services.scrapers import Scraping
 from program.services.scrapers.shared import rtn
 from program.types import Event
+from program.services.downloaders.models import TorrentContainer, TorrentInfo
 
 
 class Stream(BaseModel):
@@ -38,8 +39,8 @@ class StartSessionResponse(BaseModel):
     message: str
     session_id: str
     torrent_id: str
-    torrent_info: dict
-    containers: Optional[List[dict]]
+    torrent_info: TorrentInfo
+    containers: Optional[List[TorrentContainer]]
     expires_at: str
 
 class SelectFilesResponse(BaseModel):
@@ -102,10 +103,10 @@ def __init__(self, id: str, item_id: str, magnet: str):
         self.id = id
         self.item_id = item_id
         self.magnet = magnet
-        self.torrent_id: Optional[str] = None
-        self.torrent_info: Optional[dict] = None
-        self.containers: Optional[list] = None
-        self.selected_files: Optional[dict] = None
+        self.torrent_id: Optional[Union[int, str]] = None
+        self.torrent_info: Optional[TorrentInfo] = None
+        self.containers: Optional[TorrentContainer] = None
+        self.selected_files: Optional[Dict[str, Dict[str, Union[str, int]]]] = None
         self.created_at: datetime = datetime.now()
         self.expires_at: datetime = datetime.now() + timedelta(minutes=5)
 
@@ -218,13 +219,10 @@ def scrape_item(request: Request, id: str) -> ScrapeItemResponse:
                 .unique()
                 .scalar_one_or_none()
             )
-        streams = scraper.scrape(item)
-        stream_containers = downloader.get_instant_availability([stream for stream in streams.keys()])
-        for stream in streams.keys():
-            if len(stream_containers.get(stream, [])) > 0:
-                streams[stream].is_cached = True
-            else:
-                streams[stream].is_cached = False
+        streams: Dict[str, Stream] = scraper.scrape(item)
+        for stream in streams.values():
+            container = downloader.get_instant_availability(stream.infohash, item.type)
+            stream.is_cached = bool(container and container.cached)
         log_string = item.log_string
 
     return {
@@ -278,23 +276,25 @@ def get_info_hash(magnet: str) -> str:
     session = session_manager.create_session(item_id or imdb_id, info_hash)
 
     try:
-        torrent_id = downloader.add_torrent(info_hash)
-        torrent_info = downloader.get_torrent_info(torrent_id)
-        containers = downloader.get_instant_availability([session.magnet]).get(session.magnet, None)
-        session_manager.update_session(session.id, torrent_id=torrent_id, torrent_info=torrent_info, containers=containers)
+        torrent_id: str = downloader.add_torrent(info_hash)
+        torrent_info: TorrentInfo = downloader.get_torrent_info(torrent_id)
+        container: Optional[TorrentContainer] = downloader.get_instant_availability(info_hash, item.type)
+        session_manager.update_session(session.id, torrent_id=torrent_id, torrent_info=torrent_info, containers=container)
     except Exception as e:
         background_tasks.add_task(session_manager.abort_session, session.id)
         raise HTTPException(status_code=500, detail=str(e))
 
-    return {
+    data = {
         "message": "Started manual scraping session",
         "session_id": session.id,
         "torrent_id": torrent_id,
         "torrent_info": torrent_info,
-        "containers": containers,
+        "containers": [container] if container else None,
         "expires_at": session.expires_at.isoformat()
     }
 
+    return StartSessionResponse(**data)
+
 @router.post(
     "/scrape/select_files/{session_id}",
     summary="Select files for torrent id, for this to be instant it requires files to be one of /manual/instant_availability response containers",
@@ -307,7 +307,7 @@ def manual_select_files(request: Request, session_id, files: Container) -> Selec
         raise HTTPException(status_code=404, detail="Session not found or expired")
     if not session.torrent_id:
         session_manager.abort_session(session_id)
-        raise HTTPException(status_code=500, detail="")
+        raise HTTPException(status_code=500, detail="No torrent ID found")
 
     download_type = "uncached"
     if files.model_dump() in session.containers:
@@ -336,7 +336,7 @@ async def manual_update_attributes(request: Request, session_id, data: Union[Con
         raise HTTPException(status_code=404, detail="Session not found or expired")
     if not session.item_id:
         session_manager.abort_session(session_id)
-        raise HTTPException(status_code=500, detail="")
+        raise HTTPException(status_code=500, detail="No item ID found")
 
     with db.Session() as db_session:
         if str(session.item_id).startswith("tt") and not db_functions.get_item_by_external_id(imdb_id=session.item_id) and not db_functions.get_item_by_id(session.item_id):
@@ -357,8 +357,8 @@ async def manual_update_attributes(request: Request, session_id, data: Union[Con
             item.reset()
             item.file = data.filename
             item.folder = data.filename
-            item.alternative_folder = session.torrent_info["original_filename"]
-            item.active_stream = {"infohash": session.magnet, "id": session.torrent_info["id"]}
+            item.alternative_folder = session.torrent_info.alternative_filename
+            item.active_stream = {"infohash": session.magnet, "id": session.torrent_info.id}
             torrent = rtn.rank(session.magnet, session.magnet)
             item.streams.append(ItemStream(torrent))
             item_ids_to_submit.append(item.id)
@@ -377,8 +377,8 @@ async def manual_update_attributes(request: Request, session_id, data: Union[Con
                         item_episode.reset()
                         item_episode.file = episode_data.filename
                         item_episode.folder = episode_data.filename
-                        item_episode.alternative_folder = session.torrent_info["original_filename"]
-                        item_episode.active_stream = {"infohash": session.magnet, "id": session.torrent_info["id"]}
+                        item_episode.alternative_folder = session.torrent_info.alternative_filename
+                        item_episode.active_stream = {"infohash": session.magnet, "id": session.torrent_info.id}
                         torrent = rtn.rank(session.magnet, session.magnet)
                         item_episode.streams.append(ItemStream(torrent))
                         item_ids_to_submit.append(item_episode.id)