dfdfdf

cmdlet/download_torrent.py

@@ -0,0 +1,127 @@
+"""Download torrent/magnet links via AllDebrid in a dedicated cmdlet.
+
+Features:
+- Accepts magnet links and .torrent files/url
+- Uses AllDebrid API for background downloads
+- Progress tracking and worker management
+- Self-registering class-based cmdlet
+"""
+
+from __future__ import annotations
+import sys
+import uuid
+import threading
+from pathlib import Path
+from typing import Any, Dict, Optional, Sequence
+
+from SYS.logger import log
+from ._shared import Cmdlet, CmdletArg, parse_cmdlet_args
+
+class Download_Torrent(Cmdlet):
+    """Class-based download-torrent cmdlet with self-registration."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            name="download-torrent",
+            summary="Download torrent/magnet links via AllDebrid",
+            usage="download-torrent <magnet|.torrent> [options]",
+            alias=["torrent", "magnet"],
+            arg=[
+                CmdletArg(name="magnet", type="string", required=False, description="Magnet link or .torrent file/URL", variadic=True),
+                CmdletArg(name="output", type="string", description="Output directory for downloaded files"),
+                CmdletArg(name="wait", type="float", description="Wait time (seconds) for magnet processing timeout"),
+                CmdletArg(name="background", type="flag", alias="bg", description="Start download in background"),
+            ],
+            detail=["Download torrents/magnets via AllDebrid API."],
+            exec=self.run,
+        )
+        self.register()
+
+    def run(self, result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
+        parsed = parse_cmdlet_args(args, self)
+        magnet_args = parsed.get("magnet", [])
+        output_dir = Path(parsed.get("output") or Path.home() / "Downloads")
+        wait_timeout = int(float(parsed.get("wait", 600)))
+        background_mode = parsed.get("background", False)
+        api_key = config.get("alldebrid_api_key")
+        if not api_key:
+            log("AllDebrid API key not configured", file=sys.stderr)
+            return 1
+        for magnet_url in magnet_args:
+            if background_mode:
+                self._start_background_worker(magnet_url, output_dir, config, api_key, wait_timeout)
+                log(f"⧗ Torrent download queued in background: {magnet_url}")
+            else:
+                self._download_torrent_worker(str(uuid.uuid4()), magnet_url, output_dir, config, api_key, wait_timeout)
+        return 0
+
+    @staticmethod
+    def _download_torrent_worker(
+        worker_id: str,
+        magnet_url: str,
+        output_dir: Path,
+        config: Dict[str, Any],
+        api_key: str,
+        wait_timeout: int = 600,
+        worker_manager: Optional[Any] = None,
+    ) -> None:
+        try:
+            from API.alldebrid import AllDebridClient
+            client = AllDebridClient(api_key)
+            log(f"[Worker {worker_id}] Submitting magnet to AllDebrid...")
+            magnet_info = client.magnet_add(magnet_url)
+            magnet_id = int(magnet_info.get('id', 0))
+            if magnet_id <= 0:
+                log(f"[Worker {worker_id}] Magnet add failed", file=sys.stderr)
+                return
+            log(f"[Worker {worker_id}] ✓ Magnet added (ID: {magnet_id})")
+            # Poll for ready status (simplified)
+            import time
+            elapsed = 0
+            while elapsed < wait_timeout:
+                status = client.magnet_status(magnet_id)
+                if status.get('ready'):
+                    break
+                time.sleep(5)
+                elapsed += 5
+            if elapsed >= wait_timeout:
+                log(f"[Worker {worker_id}] Timeout waiting for magnet", file=sys.stderr)
+                return
+            files_result = client.magnet_links([magnet_id])
+            magnet_files = files_result.get(str(magnet_id), {})
+            files_array = magnet_files.get('files', [])
+            if not files_array:
+                log(f"[Worker {worker_id}] No files found", file=sys.stderr)
+                return
+            for file_info in files_array:
+                file_url = file_info.get('link')
+                file_name = file_info.get('name')
+                if file_url:
+                    Download_Torrent._download_file(file_url, output_dir / file_name)
+                    log(f"[Worker {worker_id}] ✓ Downloaded {file_name}")
+        except Exception as e:
+            log(f"[Worker {worker_id}] Torrent download failed: {e}", file=sys.stderr)
+
+    @staticmethod
+    def _download_file(url: str, dest: Path) -> None:
+        try:
+            import requests
+            resp = requests.get(url, stream=True)
+            with open(dest, 'wb') as f:
+                for chunk in resp.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+        except Exception as e:
+            log(f"File download failed: {e}", file=sys.stderr)
+
+    def _start_background_worker(self, magnet_url, output_dir, config, api_key, wait_timeout):
+        worker_id = f"torrent_{uuid.uuid4().hex[:6]}"
+        thread = threading.Thread(
+            target=self._download_torrent_worker,
+            args=(worker_id, magnet_url, output_dir, config, api_key, wait_timeout),
+            daemon=False,
+            name=f"TorrentWorker_{worker_id}",
+        )
+        thread.start()
+
+CMDLET = Download_Torrent()