New archi: domain driven development

Working but need to check out code

application/torrents/__init__.py

@@ -0,0 +1,11 @@
+"""Torrent use cases."""
+from .search_torrents import SearchTorrentsUseCase
+from .add_torrent import AddTorrentUseCase
+from .dto import SearchTorrentsResponse, AddTorrentResponse
+
+__all__ = [
+    "SearchTorrentsUseCase",
+    "AddTorrentUseCase",
+    "SearchTorrentsResponse",
+    "AddTorrentResponse",
+]

application/torrents/add_torrent.py

@@ -0,0 +1,85 @@
+"""Add torrent use case."""
+import logging
+
+from infrastructure.api.qbittorrent import QBittorrentClient, QBittorrentAuthError, QBittorrentAPIError
+from .dto import AddTorrentResponse
+
+logger = logging.getLogger(__name__)
+
+
+class AddTorrentUseCase:
+    """
+    Use case for adding a torrent to qBittorrent.
+    
+    This orchestrates the qBittorrent API client to add torrents.
+    """
+    
+    def __init__(self, qbittorrent_client: QBittorrentClient):
+        """
+        Initialize use case.
+        
+        Args:
+            qbittorrent_client: qBittorrent API client
+        """
+        self.qbittorrent_client = qbittorrent_client
+    
+    def execute(self, magnet_link: str) -> AddTorrentResponse:
+        """
+        Add a torrent to qBittorrent using a magnet link.
+        
+        Args:
+            magnet_link: Magnet link of the torrent to add
+        
+        Returns:
+            AddTorrentResponse with success or error information
+        """
+        try:
+            # Validate magnet link
+            if not magnet_link or not isinstance(magnet_link, str):
+                raise ValueError("Magnet link must be a non-empty string")
+            
+            if not magnet_link.startswith("magnet:"):
+                raise ValueError("Invalid magnet link format")
+            
+            logger.info("Adding torrent to qBittorrent")
+            
+            # Add torrent to qBittorrent
+            success = self.qbittorrent_client.add_torrent(magnet_link)
+            
+            if success:
+                logger.info("Torrent added successfully to qBittorrent")
+                return AddTorrentResponse(
+                    status="ok",
+                    message="Torrent added successfully to qBittorrent"
+                )
+            else:
+                logger.warning("Failed to add torrent to qBittorrent")
+                return AddTorrentResponse(
+                    status="error",
+                    error="add_failed",
+                    message="Failed to add torrent to qBittorrent"
+                )
+        
+        except QBittorrentAuthError as e:
+            logger.error(f"qBittorrent authentication error: {e}")
+            return AddTorrentResponse(
+                status="error",
+                error="authentication_failed",
+                message="Failed to authenticate with qBittorrent"
+            )
+        
+        except QBittorrentAPIError as e:
+            logger.error(f"qBittorrent API error: {e}")
+            return AddTorrentResponse(
+                status="error",
+                error="api_error",
+                message=str(e)
+            )
+        
+        except ValueError as e:
+            logger.error(f"Validation error: {e}")
+            return AddTorrentResponse(
+                status="error",
+                error="validation_failed",
+                message=str(e)
+            )

application/torrents/dto.py

@@ -0,0 +1,47 @@
+"""Torrent application DTOs."""
+from dataclasses import dataclass
+from typing import Optional, List, Dict, Any
+
+
+@dataclass
+class SearchTorrentsResponse:
+    """Response from searching for torrents."""
+    status: str
+    torrents: Optional[List[Dict[str, Any]]] = None
+    count: Optional[int] = None
+    error: Optional[str] = None
+    message: Optional[str] = None
+    
+    def to_dict(self):
+        """Convert to dict for agent compatibility."""
+        result = {"status": self.status}
+        
+        if self.error:
+            result["error"] = self.error
+            result["message"] = self.message
+        else:
+            if self.torrents is not None:
+                result["torrents"] = self.torrents
+            if self.count is not None:
+                result["count"] = self.count
+        
+        return result
+
+
+@dataclass
+class AddTorrentResponse:
+    """Response from adding a torrent."""
+    status: str
+    message: Optional[str] = None
+    error: Optional[str] = None
+    
+    def to_dict(self):
+        """Convert to dict for agent compatibility."""
+        result = {"status": self.status}
+        
+        if self.error:
+            result["error"] = self.error
+        if self.message:
+            result["message"] = self.message
+        
+        return result

application/torrents/search_torrents.py

@@ -0,0 +1,94 @@
+"""Search torrents use case."""
+import logging
+
+from infrastructure.api.knaben import KnabenClient, KnabenNotFoundError, KnabenAPIError
+from .dto import SearchTorrentsResponse
+
+logger = logging.getLogger(__name__)
+
+
+class SearchTorrentsUseCase:
+    """
+    Use case for searching torrents.
+    
+    This orchestrates the Knaben API client to find torrents.
+    """
+    
+    def __init__(self, knaben_client: KnabenClient):
+        """
+        Initialize use case.
+        
+        Args:
+            knaben_client: Knaben API client
+        """
+        self.knaben_client = knaben_client
+    
+    def execute(self, media_title: str, limit: int = 10) -> SearchTorrentsResponse:
+        """
+        Search for torrents by media title.
+        
+        Args:
+            media_title: Title of the media to search for
+            limit: Maximum number of results
+        
+        Returns:
+            SearchTorrentsResponse with torrent information or error
+        """
+        try:
+            # Search for torrents
+            results = self.knaben_client.search(media_title, limit=limit)
+            
+            if not results:
+                logger.info(f"No torrents found for '{media_title}'")
+                return SearchTorrentsResponse(
+                    status="error",
+                    error="not_found",
+                    message=f"No torrents found for '{media_title}'"
+                )
+            
+            # Convert to dict format
+            torrents = []
+            for torrent in results:
+                torrents.append({
+                    "name": torrent.title,
+                    "size": torrent.size,
+                    "seeders": torrent.seeders,
+                    "leechers": torrent.leechers,
+                    "magnet": torrent.magnet,
+                    "info_hash": torrent.info_hash,
+                    "tracker": torrent.tracker,
+                    "upload_date": torrent.upload_date,
+                    "category": torrent.category
+                })
+            
+            logger.info(f"Found {len(torrents)} torrents for '{media_title}'")
+            
+            return SearchTorrentsResponse(
+                status="ok",
+                torrents=torrents,
+                count=len(torrents)
+            )
+        
+        except KnabenNotFoundError as e:
+            logger.info(f"Torrents not found: {e}")
+            return SearchTorrentsResponse(
+                status="error",
+                error="not_found",
+                message=str(e)
+            )
+        
+        except KnabenAPIError as e:
+            logger.error(f"Knaben API error: {e}")
+            return SearchTorrentsResponse(
+                status="error",
+                error="api_error",
+                message=str(e)
+            )
+        
+        except ValueError as e:
+            logger.error(f"Validation error: {e}")
+            return SearchTorrentsResponse(
+                status="error",
+                error="validation_failed",
+                message=str(e)
+            )