Aria2-rust 0.3.0__tar.gz

aria2_rust-0.3.0/.gitignore

@@ -0,0 +1,23 @@
+target/
+aria2_original/
+aria2-next/
+.trae/
+bindings/nodejs/node_modules/
+bindings/python/aria2_rust_client/__pycache__/
+bindings/python/tests/e2e/__pycache__/
+bindings/python/tests/unit/__pycache__/
+bindings/python/tests/integration/__pycache__/
+bindings/python/tests/__pycache__/
+*.txt
+!aria2/tests/fixtures/compatibility_option_inventory.txt
+!aria2-core/tests/fixtures/compatibility_option_policies.txt
+*.md
+*.7z
+*.bak
+*.bin
+!docs/
+AGENTS.md
+docs/compatibility-status.md
+docs/MIGRATION.md
+.codex-python-deps/
+!docs/compatibility-status.md

aria2_rust-0.3.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: Aria2_rust
+Version: 0.3.0
+Summary: Python SDK for aria2-rust JSON-RPC interface
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.25
+Requires-Dist: typing-extensions>=4.0
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: respx>=0.20; extra == 'dev'

aria2_rust-0.3.0/aria2_rust_client/__init__.py

@@ -0,0 +1,33 @@
+from .client import Aria2Client
+from .errors import Aria2Error, AuthError, ConnectionError, RpcError, TimeoutError
+from .events import EventSubscriber
+from .types import (
+    DownloadEvent,
+    DownloadStatus,
+    EventType,
+    FileInfo,
+    GlobalStat,
+    SessionInfo,
+    StatusInfo,
+    UriEntry,
+    VersionInfo,
+)
+
+__all__ = [
+    "Aria2Client",
+    "Aria2Error",
+    "AuthError",
+    "ConnectionError",
+    "RpcError",
+    "TimeoutError",
+    "EventSubscriber",
+    "DownloadEvent",
+    "DownloadStatus",
+    "EventType",
+    "FileInfo",
+    "GlobalStat",
+    "SessionInfo",
+    "StatusInfo",
+    "UriEntry",
+    "VersionInfo",
+]

aria2_rust-0.3.0/aria2_rust_client/client.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import base64
+from typing import Any, Dict, List, Optional
+
+from typing_extensions import Self
+
+from .errors import Aria2Error
+from .events import EventSubscriber
+from .transport import HttpTransport, Transport, WebSocketTransport
+from .types import (
+    EventType,
+    GlobalStat,
+    SessionInfo,
+    StatusInfo,
+    VersionInfo,
+)
+
+
+def _http_to_ws(url: str) -> str:
+    if url.startswith("https://"):
+        return "wss://" + url[8:]
+    if url.startswith("http://"):
+        return "ws://" + url[7:]
+    return url
+
+
+class Aria2Client:
+    def __init__(
+        self,
+        url: str = "http://localhost:6800/jsonrpc",
+        token: Optional[str] = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._url = url
+        self._token = token
+        self._timeout = timeout
+        self._transport: Transport
+
+        if url.startswith("ws://") or url.startswith("wss://"):
+            self._transport = WebSocketTransport(url, token, timeout)
+        else:
+            self._transport = HttpTransport(url, token, timeout)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    async def _call(self, method: str, params: Optional[list] = None) -> Any:
+        return await self._transport.send_request(method, params or [])
+
+    async def add_uri(
+        self, uris: List[str], options: Optional[Dict] = None
+    ) -> str:
+        params: list = [uris]
+        if options is not None:
+            params.append(options)
+        result = await self._call("aria2.addUri", params)
+        return str(result)
+
+    async def add_torrent(
+        self, torrent: bytes, options: Optional[Dict] = None
+    ) -> str:
+        encoded = base64.b64encode(torrent).decode("ascii")
+        params: list = [encoded]
+        if options is not None:
+            params.append(options)
+        result = await self._call("aria2.addTorrent", params)
+        return str(result)
+
+    async def add_metalink(
+        self, metalink: bytes, options: Optional[Dict] = None
+    ) -> str:
+        encoded = base64.b64encode(metalink).decode("ascii")
+        params: list = [encoded]
+        if options is not None:
+            params.append(options)
+        result = await self._call("aria2.addMetalink", params)
+        return str(result)
+
+    async def remove(self, gid: str) -> str:
+        result = await self._call("aria2.remove", [gid])
+        return str(result)
+
+    async def pause(self, gid: str) -> str:
+        result = await self._call("aria2.pause", [gid])
+        return str(result)
+
+    async def unpause(self, gid: str) -> str:
+        result = await self._call("aria2.unpause", [gid])
+        return str(result)
+
+    async def force_pause(self, gid: str) -> str:
+        result = await self._call("aria2.forcePause", [gid])
+        return str(result)
+
+    async def force_remove(self, gid: str) -> str:
+        result = await self._call("aria2.forceRemove", [gid])
+        return str(result)
+
+    async def force_unpause(self, gid: str) -> str:
+        result = await self._call("aria2.forceUnpause", [gid])
+        return str(result)
+
+    async def tell_status(
+        self, gid: str, keys: Optional[List[str]] = None
+    ) -> StatusInfo:
+        params: list = [gid]
+        if keys is not None:
+            params.append(keys)
+        result = await self._call("aria2.tellStatus", params)
+        if isinstance(result, dict):
+            return StatusInfo.from_dict(result)
+        raise Aria2Error(f"Unexpected result type for tellStatus: {type(result)}")
+
+    async def tell_active(
+        self, keys: Optional[List[str]] = None
+    ) -> List[StatusInfo]:
+        params: list = []
+        if keys is not None:
+            params.append(keys)
+        result = await self._call("aria2.tellActive", params)
+        if isinstance(result, list):
+            return [StatusInfo.from_dict(item) for item in result if isinstance(item, dict)]
+        raise Aria2Error(f"Unexpected result type for tellActive: {type(result)}")
+
+    async def tell_waiting(
+        self, offset: int, num: int, keys: Optional[List[str]] = None
+    ) -> List[StatusInfo]:
+        params: list = [offset, num]
+        if keys is not None:
+            params.append(keys)
+        result = await self._call("aria2.tellWaiting", params)
+        if isinstance(result, list):
+            return [StatusInfo.from_dict(item) for item in result if isinstance(item, dict)]
+        raise Aria2Error(f"Unexpected result type for tellWaiting: {type(result)}")
+
+    async def tell_stopped(
+        self, offset: int, num: int, keys: Optional[List[str]] = None
+    ) -> List[StatusInfo]:
+        params: list = [offset, num]
+        if keys is not None:
+            params.append(keys)
+        result = await self._call("aria2.tellStopped", params)
+        if isinstance(result, list):
+            return [StatusInfo.from_dict(item) for item in result if isinstance(item, dict)]
+        raise Aria2Error(f"Unexpected result type for tellStopped: {type(result)}")
+
+    async def get_global_stat(self) -> GlobalStat:
+        result = await self._call("aria2.getGlobalStat")
+        if isinstance(result, dict):
+            return GlobalStat.from_dict(result)
+        raise Aria2Error(f"Unexpected result type for getGlobalStat: {type(result)}")
+
+    async def purge_download_result(self) -> str:
+        result = await self._call("aria2.purgeDownloadResult")
+        return str(result) if result is not None else "OK"
+
+    async def remove_download_result(self, gid: str) -> str:
+        result = await self._call("aria2.removeDownloadResult", [gid])
+        return str(result) if result is not None else "OK"
+
+    async def get_global_option(self) -> Dict:
+        result = await self._call("aria2.getGlobalOption")
+        return result if isinstance(result, dict) else {}
+
+    async def change_global_option(self, options: Dict) -> str:
+        result = await self._call("aria2.changeGlobalOption", [options])
+        return str(result) if result is not None else "OK"
+
+    async def get_option(self, gid: str) -> Dict:
+        result = await self._call("aria2.getOption", [gid])
+        return result if isinstance(result, dict) else {}
+
+    async def change_option(self, gid: str, options: Dict) -> str:
+        result = await self._call("aria2.changeOption", [gid, options])
+        return str(result) if result is not None else "OK"
+
+    async def get_version(self) -> VersionInfo:
+        result = await self._call("aria2.getVersion")
+        if isinstance(result, dict):
+            return VersionInfo.from_dict(result)
+        raise Aria2Error(f"Unexpected result type for getVersion: {type(result)}")
+
+    async def get_session_info(self) -> SessionInfo:
+        result = await self._call("aria2.getSessionInfo")
+        if isinstance(result, dict):
+            return SessionInfo.from_dict(result)
+        raise Aria2Error(f"Unexpected result type for getSessionInfo: {type(result)}")
+
+    async def shutdown(self) -> str:
+        result = await self._call("aria2.shutdown")
+        return str(result) if result is not None else "OK"
+
+    async def force_shutdown(self) -> str:
+        result = await self._call("aria2.forceShutdown")
+        return str(result) if result is not None else "OK"
+
+    async def save_session(self) -> str:
+        result = await self._call("aria2.saveSession")
+        return str(result) if result is not None else "OK"
+
+    async def subscribe_events(
+        self, filter: Optional[List[EventType]] = None
+    ) -> EventSubscriber:
+        ws_url = _http_to_ws(self._url)
+        subscriber = EventSubscriber(ws_url, self._token, filter)
+        await subscriber.start()
+        return subscriber
+
+    async def close(self) -> None:
+        await self._transport.close()

aria2_rust-0.3.0/aria2_rust_client/errors.py

@@ -0,0 +1,32 @@
+class Aria2Error(Exception):
+    code: int = -1
+
+    def __init__(self, message: str, code: int = -1) -> None:
+        self.code = code
+        super().__init__(message)
+
+
+class ConnectionError(Aria2Error):
+    code: int = -2
+
+    def __init__(self, message: str = "Connection error", code: int = -2) -> None:
+        super().__init__(message, code)
+
+
+class AuthError(Aria2Error):
+    code: int = -3
+
+    def __init__(self, message: str = "Authentication error", code: int = -3) -> None:
+        super().__init__(message, code)
+
+
+class RpcError(Aria2Error):
+    def __init__(self, message: str, code: int = -1) -> None:
+        super().__init__(message, code)
+
+
+class TimeoutError(Aria2Error):
+    code: int = -4
+
+    def __init__(self, message: str = "Request timeout", code: int = -4) -> None:
+        super().__init__(message, code)

aria2_rust-0.3.0/aria2_rust_client/events.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import List, Optional
+
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
+
+from .errors import ConnectionError, TimeoutError
+from .types import DownloadEvent, EventType
+
+_EVENT_METHOD_MAP: dict[str, EventType] = {
+    "aria2.onDownloadStart": EventType.DOWNLOAD_START,
+    "aria2.onDownloadPause": EventType.DOWNLOAD_PAUSE,
+    "aria2.onDownloadStop": EventType.DOWNLOAD_STOP,
+    "aria2.onDownloadComplete": EventType.DOWNLOAD_COMPLETE,
+    "aria2.onDownloadError": EventType.DOWNLOAD_ERROR,
+    "aria2.onBtDownloadComplete": EventType.BT_DOWNLOAD_COMPLETE,
+}
+
+
+class EventSubscriber:
+    def __init__(
+        self,
+        ws_url: str,
+        token: Optional[str] = None,
+        filter: Optional[List[EventType]] = None,
+    ) -> None:
+        self._ws_url = ws_url
+        self._token = token
+        self._filter = set(filter) if filter is not None else None
+        self._ws: Any = None
+        self._listener_task: Optional[asyncio.Task] = None
+        self._queue: asyncio.Queue[Optional[DownloadEvent]] = asyncio.Queue()
+        self._closed = False
+        self._reconnect_attempts = 0
+        self._max_reconnect_attempts = 5
+
+    def _should_include(self, event: DownloadEvent) -> bool:
+        if self._filter is None:
+            return True
+        return event.event_type in self._filter
+
+    async def _connect(self) -> None:
+        try:
+            import websockets
+
+            self._ws = await websockets.connect(self._ws_url)
+            self._reconnect_attempts = 0
+        except Exception as exc:
+            raise ConnectionError(f"Failed to connect WebSocket: {exc}") from exc
+
+    async def _listen(self) -> None:
+        while not self._closed:
+            if self._ws is None:
+                try:
+                    await self._connect()
+                except ConnectionError:
+                    if not await self._try_reconnect():
+                        break
+                    continue
+
+            try:
+                async for raw_message in self._ws:
+                    try:
+                        message = json.loads(raw_message)
+                    except (json.JSONDecodeError, TypeError):
+                        continue
+
+                    method = message.get("method", "")
+                    if not method.startswith("aria2.on"):
+                        continue
+
+                    params = message.get("params", [{}])
+                    event_params = params[0] if isinstance(params, list) and params else {}
+                    if not isinstance(event_params, dict):
+                        event_params = {}
+
+                    event = DownloadEvent.from_rpc_notification(method, event_params)
+                    if self._should_include(event):
+                        await self._queue.put(event)
+            except asyncio.CancelledError:
+                break
+            except Exception:
+                if self._closed:
+                    break
+                if not await self._try_reconnect():
+                    break
+
+        await self._queue.put(None)
+
+    async def _try_reconnect(self) -> bool:
+        if self._closed:
+            return False
+        if self._reconnect_attempts >= self._max_reconnect_attempts:
+            return False
+
+        backoff = min(2**self._reconnect_attempts, 16)
+        self._reconnect_attempts += 1
+
+        try:
+            await asyncio.sleep(backoff)
+        except asyncio.CancelledError:
+            return False
+
+        try:
+            await self._connect()
+            return True
+        except ConnectionError:
+            return await self._try_reconnect()
+
+    async def start(self) -> None:
+        await self._connect()
+        self._listener_task = asyncio.create_task(self._listen())
+
+    def __aiter__(self) -> Self:
+        return self
+
+    async def __anext__(self) -> DownloadEvent:
+        if self._closed:
+            raise StopAsyncIteration
+
+        event = await self._queue.get()
+        if event is None:
+            raise StopAsyncIteration
+        return event
+
+    async def close(self) -> None:
+        self._closed = True
+
+        if self._listener_task is not None:
+            self._listener_task.cancel()
+            try:
+                await self._listener_task
+            except asyncio.CancelledError:
+                pass
+            self._listener_task = None
+
+        if self._ws is not None:
+            try:
+                await self._ws.close()
+            except Exception:
+                pass
+            self._ws = None
+
+        while not self._queue.empty():
+            try:
+                self._queue.get_nowait()
+            except asyncio.QueueEmpty:
+                break