Updated folder structure (for Docker)

brain/application/torrents/__init__.py

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

brain/application/torrents/add_torrent.py

@@ -0,0 +1,84 @@
+"""Add torrent use case."""
+
+import logging
+
+from infrastructure.api.qbittorrent import (
+    QBittorrentAPIError,
+    QBittorrentAuthError,
+    QBittorrentClient,
+)
+
+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)
+            )

brain/application/torrents/dto.py

@@ -0,0 +1,50 @@
+"""Torrent application DTOs."""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class SearchTorrentsResponse:
+    """Response from searching for torrents."""
+
+    status: str
+    torrents: list[dict[str, Any]] | None = None
+    count: int | None = None
+    error: str | None = None
+    message: str | None = 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: str | None = None
+    error: str | None = 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

brain/application/torrents/search_torrents.py

@@ -0,0 +1,90 @@
+"""Search torrents use case."""
+
+import logging
+
+from infrastructure.api.knaben import KnabenAPIError, KnabenClient, KnabenNotFoundError
+
+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)
+            )