Aria2-rust 0.3.0__py3-none-any.whl

aria2_rust-0.3.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,9 @@
+aria2_rust_client/__init__.py,sha256=JZF-ocVz8JulvKYCdwy93xa0kosx9FqT_5MxL5XAKzo,639
+aria2_rust_client/client.py,sha256=j8THCJcBkhuC0aqo98mpqSra8O8P4veFKBKotNm8PW8,7815
+aria2_rust_client/errors.py,sha256=Fs5CLfLb1sQHMMvBzkQp5oPxowyhP54-mZD2y7P8D7o,836
+aria2_rust_client/events.py,sha256=YUUL9NCyCgNu57kqBCQJo3i-lrWgqdfufLnUOU1zJPk,4765
+aria2_rust_client/transport.py,sha256=4JIswNEr2hkRqyFppTOQzzm-93gSOUosRoOnuwpBWB4,9070
+aria2_rust_client/types.py,sha256=bjZUhRVtIVjm-iQPfiVOCDnlO1Bf6brFobLprpjDFQs,5916
+aria2_rust-0.3.0.dist-info/METADATA,sha256=cgvGIdVDOvOl9Jwj4EhUIhUK1Cb_lFKL2VBmPkBUa8A,433
+aria2_rust-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aria2_rust-0.3.0.dist-info/RECORD,,

aria2_rust-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

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_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_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_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

aria2_rust_client/transport.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Callable, Dict, List, Optional, Protocol, runtime_checkable
+
+import httpx
+
+from .errors import AuthError, ConnectionError, RpcError, TimeoutError
+
+
+def _is_auth_rpc_error(code: Any, message: str) -> bool:
+    """Recognize auth failures without confusing aria2 domain code 1 errors."""
+    if code == -32001:
+        return True
+
+    normalized = message.casefold()
+    return any(
+        marker in normalized
+        for marker in (
+            "unauthorized",
+            "auth fail",
+            "authentication",
+            "authorization",
+            "invalid token",
+            "token required",
+        )
+    )
+
+
+@runtime_checkable
+class Transport(Protocol):
+    async def send_request(self, method: str, params: list) -> Any:
+        ...
+
+    async def close(self) -> None:
+        ...
+
+
+class HttpTransport:
+    def __init__(
+        self,
+        url: str,
+        token: Optional[str] = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._url = url
+        self._token = token
+        self._timeout = timeout
+        self._id_counter = 0
+        self._client = httpx.AsyncClient(timeout=timeout)
+
+    def _next_id(self) -> int:
+        self._id_counter += 1
+        return self._id_counter
+
+    def _build_request(self, method: str, params: list) -> Dict[str, Any]:
+        request_params: list = []
+        if self._token is not None:
+            request_params.append(f"token:{self._token}")
+        request_params.extend(params)
+        return {
+            "jsonrpc": "2.0",
+            "id": self._next_id(),
+            "method": method,
+            "params": request_params,
+        }
+
+    async def send_request(self, method: str, params: list) -> Any:
+        payload = self._build_request(method, params)
+        try:
+            response = await self._client.post(self._url, json=payload)
+        except (httpx.ConnectError, httpx.ConnectTimeout) as exc:
+            raise ConnectionError(f"Connection error: {exc}") from exc
+        except httpx.TimeoutException as exc:
+            raise TimeoutError(f"Request timed out: {exc}") from exc
+
+        # aria2 returns a JSON-RPC error body with HTTP 400 for execution
+        # failures. Decode the body before treating the HTTP status as a
+        # transport failure, just like the Node.js adapter.
+        try:
+            data = response.json()
+        except (TypeError, ValueError) as exc:
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as status_error:
+                if status_error.response.status_code in (401, 403):
+                    raise AuthError(f"Authentication failed: {status_error}") from status_error
+                raise ConnectionError(
+                    f"HTTP error {status_error.response.status_code}: {status_error}"
+                ) from status_error
+            raise ConnectionError("Invalid JSON response") from exc
+
+        if "error" in data:
+            err = data["error"]
+            err_msg = err.get("message", "Unknown RPC error")
+            err_code = err.get("code", -1)
+            if _is_auth_rpc_error(err_code, err_msg):
+                raise AuthError(err_msg, err_code)
+            raise RpcError(err_msg, err_code)
+
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            if exc.response.status_code in (401, 403):
+                raise AuthError(f"Authentication failed: {exc}") from exc
+            raise ConnectionError(f"HTTP error {exc.response.status_code}: {exc}") from exc
+        except httpx.HTTPError as exc:
+            raise ConnectionError(f"Connection error: {exc}") from exc
+
+        return data.get("result")
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+
+class WebSocketTransport:
+    def __init__(
+        self,
+        url: str,
+        token: Optional[str] = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._url = url
+        self._token = token
+        self._timeout = timeout
+        self._id_counter = 0
+        self._ws: Any = None
+        self._pending: Dict[int, asyncio.Future] = {}
+        self._listener_task: Optional[asyncio.Task] = None
+        self._event_callback: Optional[Callable[[str, Dict[str, Any]], None]] = None
+        self._connected = False
+
+    def _next_id(self) -> int:
+        self._id_counter += 1
+        return self._id_counter
+
+    def set_event_callback(
+        self, callback: Callable[[str, Dict[str, Any]], None]
+    ) -> None:
+        self._event_callback = callback
+
+    async def _ensure_connected(self) -> None:
+        if self._connected and self._ws is not None:
+            return
+        try:
+            import websockets
+
+            self._ws = await websockets.connect(
+                self._url, open_timeout=self._timeout
+            )
+            self._connected = True
+            self._listener_task = asyncio.create_task(self._listen())
+        except asyncio.TimeoutError as exc:
+            raise TimeoutError(f"WebSocket connection timed out: {exc}") from exc
+        except Exception as exc:
+            raise ConnectionError(f"WebSocket connection failed: {exc}") from exc
+
+    async def _listen(self) -> None:
+        try:
+            async for raw_message in self._ws:
+                try:
+                    message = json.loads(raw_message)
+                except (json.JSONDecodeError, TypeError):
+                    continue
+
+                if "method" in message and message["method"].startswith("aria2.on"):
+                    if self._event_callback is not None:
+                        params = message.get("params", [{}])
+                        event_params = params[0] if isinstance(params, list) and params else {}
+                        if not isinstance(event_params, dict):
+                            event_params = {}
+                        try:
+                            self._event_callback(message["method"], event_params)
+                        except Exception:
+                            pass
+                    continue
+
+                msg_id = message.get("id")
+                if msg_id is not None and msg_id in self._pending:
+                    future = self._pending.pop(msg_id)
+                    if not future.done():
+                        if "error" in message:
+                            future.set_exception(
+                                RpcError(
+                                    message["error"].get("message", "Unknown RPC error"),
+                                    message["error"].get("code", -1),
+                                )
+                            )
+                        else:
+                            future.set_result(message.get("result"))
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            for future in self._pending.values():
+                if not future.done():
+                    future.set_exception(
+                        ConnectionError("WebSocket connection lost")
+                    )
+            self._pending.clear()
+        finally:
+            self._connected = False
+
+    def _build_request(self, method: str, params: list) -> Dict[str, Any]:
+        request_params: list = []
+        if self._token is not None:
+            request_params.append(f"token:{self._token}")
+        request_params.extend(params)
+        return {
+            "jsonrpc": "2.0",
+            "id": self._next_id(),
+            "method": method,
+            "params": request_params,
+        }
+
+    async def send_request(self, method: str, params: list) -> Any:
+        await self._ensure_connected()
+        payload = self._build_request(method, params)
+        request_id = payload["id"]
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future = loop.create_future()
+        self._pending[request_id] = future
+
+        try:
+            await self._ws.send(json.dumps(payload))
+        except Exception as exc:
+            self._pending.pop(request_id, None)
+            raise ConnectionError(f"Failed to send WebSocket message: {exc}") from exc
+
+        try:
+            return await asyncio.wait_for(future, timeout=self._timeout)
+        except asyncio.TimeoutError:
+            self._pending.pop(request_id, None)
+            raise TimeoutError(f"Request timed out after {self._timeout}s")
+
+    async def close(self) -> None:
+        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
+
+        for future in self._pending.values():
+            if not future.done():
+                future.set_exception(ConnectionError("Transport closed"))
+        self._pending.clear()
+        self._connected = False

aria2_rust_client/types.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+def _camel_to_snake(name: str) -> str:
+    s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+
+
+def _convert_keys(data: Dict[str, Any]) -> Dict[str, Any]:
+    return {_camel_to_snake(k): v for k, v in data.items()}
+
+
+class EventType(str, Enum):
+    DOWNLOAD_START = "DOWNLOAD_START"
+    DOWNLOAD_PAUSE = "DOWNLOAD_PAUSE"
+    DOWNLOAD_STOP = "DOWNLOAD_STOP"
+    DOWNLOAD_COMPLETE = "DOWNLOAD_COMPLETE"
+    DOWNLOAD_ERROR = "DOWNLOAD_ERROR"
+    BT_DOWNLOAD_COMPLETE = "BT_DOWNLOAD_COMPLETE"
+
+
+class DownloadStatus(str, Enum):
+    ACTIVE = "active"
+    WAITING = "waiting"
+    PAUSED = "paused"
+    ERROR = "error"
+    COMPLETE = "complete"
+    REMOVED = "removed"
+
+
+_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,
+}
+
+
+@dataclass
+class UriEntry:
+    uri: Optional[str] = None
+    status: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> UriEntry:
+        converted = _convert_keys(data)
+        return cls(
+            uri=converted.get("uri"),
+            status=converted.get("status"),
+        )
+
+
+@dataclass
+class FileInfo:
+    index: Optional[str] = None
+    path: Optional[str] = None
+    length: Optional[str] = None
+    completed_length: Optional[str] = None
+    selected: Optional[str] = None
+    uris: List[UriEntry] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> FileInfo:
+        converted = _convert_keys(data)
+        uris_data = converted.get("uris") or []
+        uris = [UriEntry.from_dict(u) if isinstance(u, dict) else u for u in uris_data]
+        return cls(
+            index=converted.get("index"),
+            path=converted.get("path"),
+            length=converted.get("length"),
+            completed_length=converted.get("completed_length"),
+            selected=converted.get("selected"),
+            uris=uris,
+        )
+
+
+@dataclass
+class StatusInfo:
+    gid: Optional[str] = None
+    total_length: Optional[str] = None
+    completed_length: Optional[str] = None
+    upload_length: Optional[str] = None
+    download_speed: Optional[str] = None
+    upload_speed: Optional[str] = None
+    error_code: Optional[str] = None
+    status: Optional[str] = None
+    dir: Optional[str] = None
+    files: List[FileInfo] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> StatusInfo:
+        converted = _convert_keys(data)
+        files_data = converted.get("files") or []
+        files = [FileInfo.from_dict(f) if isinstance(f, dict) else f for f in files_data]
+        return cls(
+            gid=converted.get("gid"),
+            total_length=converted.get("total_length"),
+            completed_length=converted.get("completed_length"),
+            upload_length=converted.get("upload_length"),
+            download_speed=converted.get("download_speed"),
+            upload_speed=converted.get("upload_speed"),
+            error_code=converted.get("error_code"),
+            status=converted.get("status"),
+            dir=converted.get("dir"),
+            files=files,
+        )
+
+
+@dataclass
+class GlobalStat:
+    download_speed: Optional[str] = None
+    upload_speed: Optional[str] = None
+    num_active: Optional[str] = None
+    num_waiting: Optional[str] = None
+    num_stopped: Optional[str] = None
+    num_stopped_total: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> GlobalStat:
+        converted = _convert_keys(data)
+        return cls(
+            download_speed=converted.get("download_speed"),
+            upload_speed=converted.get("upload_speed"),
+            num_active=converted.get("num_active"),
+            num_waiting=converted.get("num_waiting"),
+            num_stopped=converted.get("num_stopped"),
+            num_stopped_total=converted.get("num_stopped_total"),
+        )
+
+
+@dataclass
+class VersionInfo:
+    version: Optional[str] = None
+    enabled_features: List[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> VersionInfo:
+        converted = _convert_keys(data)
+        features = converted.get("enabled_features") or []
+        return cls(
+            version=converted.get("version"),
+            enabled_features=list(features) if isinstance(features, (list, tuple)) else [],
+        )
+
+
+@dataclass
+class SessionInfo:
+    session_id: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SessionInfo:
+        converted = _convert_keys(data)
+        return cls(session_id=converted.get("session_id"))
+
+
+@dataclass
+class DownloadEvent:
+    event_type: EventType
+    gid: Optional[str] = None
+    error_code: Optional[str] = None
+    files: Optional[List[FileInfo]] = None
+
+    @classmethod
+    def from_rpc_notification(cls, method: str, params: Dict[str, Any]) -> DownloadEvent:
+        event_type = _EVENT_METHOD_MAP.get(method)
+        if event_type is None:
+            event_type = EventType.DOWNLOAD_START
+        converted = _convert_keys(params)
+        files_data = converted.get("files")
+        files = None
+        if files_data and isinstance(files_data, list):
+            files = [FileInfo.from_dict(f) if isinstance(f, dict) else f for f in files_data]
+        return cls(
+            event_type=event_type,
+            gid=converted.get("gid"),
+            error_code=converted.get("error_code"),
+            files=files,
+        )