cdmclient 1.2.4__py3-none-any.whl

cdm_client/cdm_client.py

@@ -0,0 +1,246 @@
+import logging
+import os
+import shutil
+from enum import Enum
+from logging.handlers import SysLogHandler
+from time import sleep
+from typing import Optional
+
+import requests
+
+from cdm_client.config import Config
+from cdm_client.database_adapter import DatabaseAdapter
+from cdm_client.torrent_client_factory import (
+    TorrentClientType,
+    create_torrent_client_adapter,
+)
+
+
+class InstructionAction(Enum):
+    STOP = "stop"
+    START = "start"
+    DELETE = "delete"
+    CLEAN = "clean"
+
+
+class CDMClient:
+    def __init__(self) -> None:
+        self._logger = self._init_logger()
+        self._config = Config()
+        self._torrent_client_adapter = create_torrent_client_adapter(
+            TorrentClientType.get_enum_from_value(self._config["client_type"]),
+            username=self._config["client_username"] or None,
+            password=self._config["client_password"] or None,
+            host=self._config["client_host"] or None,
+            port=int(self._config["client_port"])
+            if self._config["client_port"]
+            else None,
+        )
+        self._database_adapter = DatabaseAdapter()
+
+    def _init_logger(self) -> logging.Logger:
+        syslog = SysLogHandler(address="/dev/log")
+        syslog.setFormatter(
+            logging.Formatter("cdm-client %(name)s: %(levelname)s %(message)s")
+        )
+        logger = logging.getLogger("cdm-client")
+        logger.addHandler(syslog)
+        logger.setLevel(logging.INFO)
+        return logger
+
+    def _update_status(self, status_data: list[dict]) -> None:
+        resp = requests.post(
+            f"{self._config['server_host']}/api/client/status/",
+            json={"data": status_data},
+            headers={"x-api-key": self._config["api_key"]},
+            timeout=5,
+        )
+        resp.raise_for_status()
+
+    def _download_files(self, files: dict[int, str]) -> None:
+        for tracker_id, path in files.items():
+            resp = requests.get(
+                f"{self._config['server_host']}/api/client/download/{tracker_id}/",
+                headers={"x-api-key": self._config["api_key"]},
+                stream=True,
+                timeout=5,
+            )
+            resp.raise_for_status()
+            new_torrent = self._torrent_client_adapter.add_torrent(
+                resp.content, download_dir=path
+            )
+            if new_torrent is None:
+                self._logger.error(
+                    "Failed to add torrent for tracker_id=%s to %s", tracker_id, path
+                )
+                continue
+            with self._database_adapter as db_adapter:
+                status = db_adapter.create_or_update_download_torrent_mapping(
+                    tracker_id=tracker_id,
+                    torrent_hash=self._torrent_client_adapter.get_status_by_id(
+                        new_torrent.id
+                    )["hash"],
+                )
+                if not status:
+                    self._logger.error(
+                        "Failed to save download-torrent mapping: %s", status
+                    )
+            self._logger.info("Downloading torrent: %s to %s", tracker_id, path)
+
+    def _execute_instructions(self, instructions: list[dict]) -> None:
+        for instruction in instructions:
+            self._logger.info("Received instruction: %s", instruction)
+            for action, params in instruction.items():
+                if action == InstructionAction.STOP.value:
+                    self._torrent_client_adapter.pause_torrent(params["torrent_id"])
+                    self._logger.info("Stopped torrent: %s", params["torrent_id"])
+                elif action == InstructionAction.START.value:
+                    self._torrent_client_adapter.resume_torrent(params["torrent_id"])
+                    self._logger.info("Started torrent: %s", params["torrent_id"])
+                elif action == InstructionAction.DELETE.value:
+                    self.delete_download(params["torrent_id"])
+                elif action == InstructionAction.CLEAN.value:
+                    self.clean_download_paths(params["paths"])
+                else:
+                    self._logger.warning("Unknown instruction action: %s", action)
+
+    def _normalize_path(self, path: str) -> str:
+        return os.path.normpath(os.path.realpath(path))
+
+    def _is_protected_path(self, path: str, protected_paths: set[str]) -> bool:
+        normalized_path = self._normalize_path(path)
+        for protected_path in protected_paths:
+            if protected_path == normalized_path or protected_path.startswith(
+                f"{normalized_path}{os.sep}"
+            ):
+                return True
+        return False
+
+    def _delete_path(self, path: str) -> None:
+        if os.path.islink(path) or os.path.isfile(path):
+            os.remove(path)
+        else:
+            shutil.rmtree(path)
+
+    def clean_download_paths(self, paths: list[str]) -> None:
+        if not paths:
+            self._logger.warning("No clean paths provided")
+            return
+
+        status_entries = self._torrent_client_adapter.get_status()
+        protected_paths: set[str] = set()
+        for status_entry in status_entries:
+            download_dir = status_entry.get("downloadDir")
+            name = status_entry.get("name")
+            if not isinstance(download_dir, str) or not isinstance(name, str):
+                continue
+            protected_paths.add(self._normalize_path(os.path.join(download_dir, name)))
+
+        for path in paths:
+            clean_path = self._normalize_path(path)
+            if not os.path.isdir(clean_path):
+                self._logger.warning("Clean path does not exist: %s", clean_path)
+                continue
+
+            self._logger.info("Cleaning path: %s", clean_path)
+            for entry in os.scandir(clean_path):
+                entry_path = self._normalize_path(entry.path)
+                if self._is_protected_path(entry_path, protected_paths):
+                    continue
+                try:
+                    self._delete_path(entry_path)
+                    self._logger.info("Deleted stale path: %s", entry_path)
+                except FileNotFoundError:
+                    self._logger.warning(
+                        "Path disappeared during clean: %s", entry_path
+                    )
+                except OSError:
+                    self._logger.exception(
+                        "Failed to delete stale path: %s", entry_path
+                    )
+
+    def delete_download(self, torrent_id: int) -> None:
+        try:
+            status_data = self._get_download_status(
+                torrent_id=torrent_id, for_deletion=True
+            )
+            self._torrent_client_adapter.remove_torrent(torrent_id)
+            self._update_status(status_data)
+            self._force_delete_if_exists(
+                os.path.join(status_data[0]["downloadDir"], status_data[0]["name"])
+            )
+        finally:
+            with self._database_adapter as db_adapter:
+                deleted_mapping = db_adapter.delete_mapping(
+                    torrent_hash=status_data[0]["hash"]
+                )
+            self._update_status(status_data)
+
+        self._logger.info(
+            "Removed torrent and data: %s, deleted_mapping: %s",
+            torrent_id,
+            deleted_mapping,
+        )
+
+    def _force_delete_if_exists(self, file_path: str) -> None:
+        sleep(1)
+        if os.path.exists(file_path):
+            self._logger.info("Force deleting file: %s", file_path)
+            try:
+                self._delete_path(file_path)
+            except FileNotFoundError:
+                self._logger.warning("File not found during deletion")
+
+    def _get_order(self) -> None:
+        resp = requests.get(
+            f"{self._config['server_host']}/api/client/",
+            headers={"x-api-key": self._config["api_key"]},
+            timeout=5,
+        )
+        resp.raise_for_status()
+
+        files = resp.json()["data"]["files"]
+        if files:
+            self._download_files(files)
+        instructions = resp.json()["data"]["instructions"]
+        if instructions:
+            self._execute_instructions(instructions)
+            self._update_status(self._get_download_status())
+
+    def _get_download_status(
+        self, torrent_id: Optional[int] = None, for_deletion: bool = False
+    ) -> list[dict]:
+        status = []
+        if torrent_id:
+            status.append(self._torrent_client_adapter.get_status_by_id(torrent_id))
+        else:
+            status = self._torrent_client_adapter.get_status()
+        with self._database_adapter as db_adapter:
+            for status_entry in status:
+                tracker_id = db_adapter.get_tracker_id_by_torrent_hash(
+                    status_entry["hash"]
+                )
+                if tracker_id:
+                    status_entry["tracker_id"] = tracker_id
+                if for_deletion:
+                    status_entry["is_deleted"] = True
+        return status
+
+    def run(self) -> None:
+        self._logger.info("Starting cdm-client...")
+        while True:
+            try:
+                self._update_status(self._get_download_status())
+                self._get_order()
+            except Exception:
+                self._logger.exception("An error occurred.")
+            sleep(5)
+
+
+def main() -> None:
+    cdm_client = CDMClient()
+    cdm_client.run()
+
+
+if __name__ == "__main__":
+    main()

cdm_client/config.py

@@ -0,0 +1,90 @@
+import configparser
+import os
+from typing import Union
+
+from cryptography.fernet import Fernet
+
+
+class Config:
+    CONFIG_FOLDER_PATH = os.path.join(os.path.expanduser("~"), ".config", "cdm_client")
+    KEY_PATH = os.path.join(CONFIG_FOLDER_PATH, "key.key")
+    CONFIG_PATH = os.path.join(CONFIG_FOLDER_PATH, "config.ini")
+    DEFAULT_CONFIG = {
+        "connection": {
+            "server_host": "",
+            "api_key": "",
+            "client_host": "",
+            "client_port": "",
+            "client_username": "",
+            "client_password": "",
+            "client_type": "",
+        }
+    }
+    ENCRYPTED_CONFIG = ["client_password"]
+
+    def __init__(self) -> None:
+        self._key: Union[bytes, str] = ""
+        self._config = self._load_config()
+        self._check_key()
+
+    def _check_key(self) -> None:
+        if not self._key_exists:
+            self._create_key()
+        else:
+            self._read_key()
+
+    def _create_key(self) -> None:
+        self._key = Fernet.generate_key()
+        with open(self.KEY_PATH, "w", encoding="utf-8") as f:
+            f.write(self._key.decode())
+
+    def _read_key(self) -> None:
+        with open(self.KEY_PATH, "r", encoding="utf-8") as f:
+            self._key = f.read().encode()
+
+    def _load_config(self) -> configparser.ConfigParser:
+        config = configparser.ConfigParser()
+        if config.read(self.CONFIG_PATH):
+            return config
+        return self._create_config()
+
+    def _create_config(self) -> configparser.ConfigParser:
+        if not os.path.exists(self.CONFIG_FOLDER_PATH):
+            os.makedirs(self.CONFIG_FOLDER_PATH)
+        config = configparser.ConfigParser()
+        for section, configs in self.DEFAULT_CONFIG.items():
+            config[section] = {}
+            for config_key, config_value in configs.items():
+                config[section][config_key] = config_value
+        with open(self.CONFIG_PATH, "w", encoding="utf-8") as f:
+            config.write(f)
+        return config
+
+    def _decrypt(self, value: str) -> str:
+        f = Fernet(self._key)
+        return f.decrypt(value.encode()).decode()
+
+    def _encrypt(self, value: str) -> str:
+        f = Fernet(self._key)
+        return f.encrypt(value.encode()).decode()
+
+    def _write_creds(self) -> None:
+        with open(self.CONFIG_PATH, "w", encoding="utf-8") as f:
+            self._config.write(f)
+
+    @property
+    def _key_exists(self) -> bool:
+        return os.path.exists(self.KEY_PATH)
+
+    def __getitem__(self, name: str) -> str:
+        if name in self.ENCRYPTED_CONFIG:
+            try:
+                return self._decrypt(self._config["connection"][name])
+            except Exception:
+                raw_value = self._config["connection"][name]
+                self._config["connection"][name] = self._encrypt(
+                    self._config["connection"][name]
+                )
+                self._write_creds()
+                return raw_value
+        return self._config["connection"][name]

cdm_client/database_adapter.py

@@ -0,0 +1,113 @@
+import os
+from types import TracebackType
+from typing import Optional
+
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    UniqueConstraint,
+    create_engine,
+)
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+Base = declarative_base()
+
+
+class DownloadTorrentMapping(Base):
+    __tablename__ = "download_torrent_mapping"
+
+    tracker_id: int = Column(Integer, primary_key=True)  # type: ignore[assignment]
+    torrent_hash: str = Column(String(40), nullable=False, unique=True)  # type: ignore[assignment]
+
+    __table_args__ = (
+        UniqueConstraint("tracker_id", "torrent_hash", name="unique_download_torrent"),
+    )
+
+
+class DatabaseAdapter:
+    DATABASE_PATH = os.path.join(
+        os.path.expanduser("~"), ".local", "share", "cdm_client", "cdm_client.db"
+    )
+
+    def __init__(self) -> None:
+        os.makedirs(os.path.dirname(self.DATABASE_PATH), exist_ok=True)
+
+        self.engine = create_engine(f"sqlite:///{self.DATABASE_PATH}")
+        Base.metadata.create_all(self.engine)
+
+    def __enter__(self) -> "DatabaseAdapter":
+        Session = sessionmaker(bind=self.engine)
+        self.session = Session()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.session.close()
+
+    def create_or_update_download_torrent_mapping(
+        self, tracker_id: int, torrent_hash: str
+    ) -> bool:
+        if self.get_torrent_hash_by_tracker_id(tracker_id):
+            return self.update_torrent_hash(tracker_id, torrent_hash)
+        try:
+            mapping = DownloadTorrentMapping(
+                tracker_id=tracker_id, torrent_hash=torrent_hash
+            )
+            self.session.add(mapping)
+            self.session.commit()
+            return True
+        except IntegrityError:
+            self.session.rollback()
+            return False
+        except Exception:
+            self.session.rollback()
+            return False
+
+    def get_torrent_hash_by_tracker_id(self, tracker_id: int) -> Optional[str]:
+        mapping = (
+            self.session.query(DownloadTorrentMapping)
+            .filter_by(tracker_id=tracker_id)
+            .first()
+        )
+        return mapping.torrent_hash if mapping else None
+
+    def update_torrent_hash(self, tracker_id: int, new_torrent_hash: str) -> bool:
+        mapping = (
+            self.session.query(DownloadTorrentMapping)
+            .filter_by(tracker_id=tracker_id)
+            .first()
+        )
+
+        if mapping:
+            mapping.torrent_hash = new_torrent_hash
+            self.session.commit()
+            return True
+        return False
+
+    def get_tracker_id_by_torrent_hash(self, torrent_hash: str) -> Optional[int]:
+        mapping = (
+            self.session.query(DownloadTorrentMapping)
+            .filter_by(torrent_hash=torrent_hash)
+            .first()
+        )
+        return mapping.tracker_id if mapping else None
+
+    def delete_mapping(self, torrent_hash: str) -> bool:
+        mapping = (
+            self.session.query(DownloadTorrentMapping)
+            .filter_by(torrent_hash=torrent_hash)
+            .first()
+        )
+
+        if mapping:
+            self.session.delete(mapping)
+            self.session.commit()
+            return True
+        return False

cdm_client/qbittorrent_adapter.py

@@ -0,0 +1,132 @@
+import logging
+from time import sleep
+from typing import Optional
+
+from qbittorrentapi import Client, TorrentDictionary, TorrentState
+
+from cdm_client.torrent_client_adapter_base import TorrentClientAdapterBase
+
+
+class TorrentWrapper:
+    def __init__(self, torrent_dict: TorrentDictionary) -> None:
+        self._torrent_dict = torrent_dict
+
+    @property
+    def id(self) -> int:
+        return int(self._torrent_dict.hash[:8], 16)
+
+
+class QBitTorrentAdapter(TorrentClientAdapterBase):
+    def __init__(
+        self,
+        username: Optional[str] = "admin",
+        password: Optional[str] = "adminadmin",
+        host: str = "127.0.0.1",
+        port: int = 8080,
+    ) -> None:
+        self._client = Client(
+            username=username, password=password, host=host, port=port
+        )
+        self._logger = logging.getLogger("cdm-client")
+
+    def _hash_to_id(self, torrent_hash: str) -> int:
+        """Convert torrent hash to integer ID using Python's hash function."""
+        return int(torrent_hash[:8], 16)
+
+    def _map_status(self, qbittorrent_status: TorrentState) -> str:
+        status_mapping = {
+            TorrentState.ERROR: "stopped",
+            TorrentState.MISSING_FILES: "stopped",
+            TorrentState.UPLOADING: "seeding",
+            TorrentState.PAUSED_UPLOAD: "stopped",
+            TorrentState.STOPPED_UPLOAD: "stopped",
+            TorrentState.QUEUED_UPLOAD: "stopped",
+            TorrentState.STALLED_UPLOAD: "seeding",
+            TorrentState.CHECKING_UPLOAD: "checking",
+            TorrentState.FORCED_UPLOAD: "seeding",
+            TorrentState.ALLOCATING: "checking",
+            TorrentState.DOWNLOADING: "downloading",
+            TorrentState.METADATA_DOWNLOAD: "downloading",
+            TorrentState.FORCED_METADATA_DOWNLOAD: "downloading",
+            TorrentState.PAUSED_DOWNLOAD: "stopped",
+            TorrentState.STOPPED_DOWNLOAD: "stopped",
+            TorrentState.QUEUED_DOWNLOAD: "download pending",
+            TorrentState.FORCED_DOWNLOAD: "downloading",
+            TorrentState.STALLED_DOWNLOAD: "stopped",
+            TorrentState.CHECKING_DOWNLOAD: "checking",
+            TorrentState.CHECKING_RESUME_DATA: "checking",
+            TorrentState.MOVING: "checking",
+            TorrentState.UNKNOWN: "unknown",
+        }
+        return status_mapping.get(qbittorrent_status, "unknown")
+
+    def _get_status_dict(self, torrent: TorrentDictionary) -> dict:
+        return {
+            "id": self._hash_to_id(torrent.hash),
+            "hash": torrent.hash,
+            "name": torrent.name,
+            "status": self._map_status(torrent.state),
+            "progress": int(torrent.progress * 100),
+            "downloadDir": torrent.save_path,
+            "addedDate": torrent.added_on,
+            "totalSize": torrent.size,
+            "eta": torrent.eta,
+        }
+
+    def get_status(self) -> list[dict]:
+        torrents = self._client.torrents_info()
+        status = []
+        for torrent in torrents:
+            status.append(self._get_status_dict(torrent))
+        self._logger.info("Retrieved status of %s torrents", len(status))
+        return status
+
+    def get_status_by_id(self, torrent_id: int) -> dict:
+        return self._get_status_dict(self._get_torrent_by_id(torrent_id))
+
+    def _get_torrent_by_id(self, torrent_id: int) -> TorrentDictionary:
+        torrents = self._client.torrents_info()
+        for torrent in torrents:
+            if self._hash_to_id(torrent.hash) == torrent_id:
+                return torrent
+        raise ValueError(f"Torrent with ID {torrent_id} not found")
+
+    def _get_latest_torrent(self) -> Optional[TorrentDictionary]:
+        torrents = self._client.torrents_info(sort="added_on")
+        self._logger.info(
+            "Current torrents: %s", [(t.name, t.added_on) for t in torrents]
+        )
+        return torrents[-1] if len(torrents) > 0 else None
+
+    def add_torrent(
+        self, torrent: bytes, download_dir: str
+    ) -> Optional[TorrentWrapper]:
+        states_before = self._client.torrents_info()
+        self._client.torrents_add(
+            torrent_files=torrent, save_path=download_dir, is_sequential_download=True
+        )
+        for _ in range(20):  # Wait up to 10 seconds
+            if self._client.torrents_info() == states_before:
+                sleep(0.5)
+            else:
+                break
+        if self._client.torrents_info() == states_before:
+            return None
+        if last_torrent := self._get_latest_torrent():
+            self._logger.info(
+                "Added torrent: %s to %s", last_torrent.name, download_dir
+            )
+            return TorrentWrapper(last_torrent)
+        return None
+
+    def pause_torrent(self, torrent_id: int) -> None:
+        torrent = self._get_torrent_by_id(torrent_id)
+        self._client.torrents_pause(torrent_hashes=[torrent.hash])
+
+    def resume_torrent(self, torrent_id: int) -> None:
+        torrent = self._get_torrent_by_id(torrent_id)
+        self._client.torrents_resume(torrent_hashes=[torrent.hash])
+
+    def remove_torrent(self, torrent_id: int) -> None:
+        torrent = self._get_torrent_by_id(torrent_id)
+        self._client.torrents_delete(torrent_hashes=[torrent.hash], delete_files=True)

cdm_client/torrent_client_adapter_base.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Protocol
+
+
+class TorrentRef(Protocol):
+    @property
+    def id(self) -> int: ...
+
+
+class TorrentClientAdapterBase(ABC):
+    @abstractmethod
+    def __init__(self) -> None: ...
+
+    @abstractmethod
+    def get_status(self) -> list[dict]: ...
+
+    @abstractmethod
+    def get_status_by_id(self, torrent_id: int) -> dict: ...
+
+    @abstractmethod
+    def add_torrent(
+        self, torrent: bytes, download_dir: str
+    ) -> Optional[TorrentRef]: ...
+
+    @abstractmethod
+    def pause_torrent(self, torrent_id: int) -> None: ...
+
+    @abstractmethod
+    def resume_torrent(self, torrent_id: int) -> None: ...
+
+    @abstractmethod
+    def remove_torrent(self, torrent_id: int) -> None: ...

cdm_client/torrent_client_factory.py

@@ -0,0 +1,60 @@
+from enum import Enum
+from typing import Optional, TypedDict
+
+from cdm_client.qbittorrent_adapter import QBitTorrentAdapter
+from cdm_client.torrent_client_adapter_base import TorrentClientAdapterBase
+from cdm_client.transmission_adapter import TransmissionAdapter
+
+
+class TorrentClientType(Enum):
+    TRANSMISSION = "transmission"
+    QBITTORRENT = "qbittorrent"
+
+    @classmethod
+    def get_enum_from_value(cls, value: str) -> "TorrentClientType":
+        for member in cls:
+            if member.value == value:
+                return member
+        return cls.TRANSMISSION
+
+
+class AdapterKwargs(TypedDict, total=False):
+    username: str
+    password: str
+    host: str
+    port: int
+
+
+def _filter_none(
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+) -> AdapterKwargs:
+    kwargs: AdapterKwargs = {}
+    if username is not None:
+        kwargs["username"] = username
+    if password is not None:
+        kwargs["password"] = password
+    if host is not None:
+        kwargs["host"] = host
+    if port is not None:
+        kwargs["port"] = port
+    return kwargs
+
+
+def create_torrent_client_adapter(
+    client_type: TorrentClientType,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+) -> TorrentClientAdapterBase:
+    kwargs = _filter_none(username=username, password=password, host=host, port=port)
+
+    if client_type == TorrentClientType.TRANSMISSION:
+        return TransmissionAdapter(**kwargs)
+    if client_type == TorrentClientType.QBITTORRENT:
+        return QBitTorrentAdapter(**kwargs)
+    else:
+        raise ValueError(f"Unsupported torrent client type: {client_type}")

cdm_client/transmission_adapter.py

@@ -0,0 +1,59 @@
+import logging
+from typing import Optional
+
+from transmission_rpc import Client, Torrent
+
+from cdm_client.torrent_client_adapter_base import TorrentClientAdapterBase
+
+
+class TransmissionAdapter(TorrentClientAdapterBase):
+    def __init__(
+        self,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        host: str = "127.0.0.1",
+        port: int = 9091,
+    ) -> None:
+        self._client = Client(
+            username=username, password=password, host=host, port=port
+        )
+        # The sequential download setting is not working somehow :(
+        self._client.set_session(rename_partial_files=False, sequential_download=True)
+        self._logger = logging.getLogger("cdm-client")
+
+    def _get_status_dict(self, torrent: Torrent) -> dict:
+        return {
+            "id": torrent.id,
+            "hash": torrent.hashString,
+            "name": torrent.name,
+            "status": torrent.status.value,
+            "progress": int(torrent.progress),
+            "downloadDir": torrent.download_dir,
+            "addedDate": torrent.added_date.timestamp(),
+            "totalSize": torrent.total_size,
+            "eta": torrent.eta.total_seconds() if torrent.eta else None,
+        }
+
+    def get_status(self) -> list[dict]:
+        torrents = self._client.get_torrents()
+        status = []
+        for torrent in torrents:
+            status.append(self._get_status_dict(torrent))
+        self._logger.info("Retrieved status of %s torrents", len(status))
+        return status
+
+    def get_status_by_id(self, torrent_id: int) -> dict:
+        torrent = self._client.get_torrent(torrent_id)
+        return self._get_status_dict(torrent)
+
+    def add_torrent(self, torrent: bytes, download_dir: str) -> Torrent:
+        return self._client.add_torrent(torrent, download_dir=download_dir)
+
+    def pause_torrent(self, torrent_id: int) -> None:
+        return self._client.stop_torrent(ids=[torrent_id])
+
+    def resume_torrent(self, torrent_id: int) -> None:
+        return self._client.start_torrent(ids=[torrent_id])
+
+    def remove_torrent(self, torrent_id: int) -> None:
+        return self._client.remove_torrent(ids=[torrent_id], delete_data=True)

cdmclient-1.2.4.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: cdmclient
+Version: 1.2.4
+Summary: CDM - Centralized Download Manager Client
+Project-URL: Homepage, https://github.com/radaron/CDMServer/tree/master/client
+Project-URL: Repository, https://github.com/radaron/CDMServer
+Author-email: Aron Radics <radics.aron.jozsef@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Aron Radics
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: cryptography
+Requires-Dist: qbittorrent-api>=2025.7.0
+Requires-Dist: requests
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: transmission-rpc
+Description-Content-Type: text/markdown
+
+# CDMClient
+**CDM - Centralized Download Manager Client**
+CDMClient is the client application for the [CDM Server](../README.md).
+
+This client communicates with the CDM Server to periodically send the download status from Transmission/QBittorrent and check for new torrent files to download. If new torrents are available, they are downloaded and added to Transmission/QBittorrent client.
+
+## Installation
+
+### Install or Upgrade the Package
+Run the following command to install or upgrade CDMClient:
+```shell
+python3 -m pip install --upgrade cdmclient --user
+```
+
+### Create a Systemd Service
+To set up CDMClient as a systemd service, execute the following commands:
+
+1. Create the service file:
+   ```shell
+   echo "[Unit]
+   Description=cdm-client service
+   After=multi-user.target
+   Conflicts=getty@tty1.service
+
+   [Service]
+   User=${USER}
+   Type=simple
+   Environment=LC_ALL=C.UTF-8
+   Environment=LANG=C.UTF-8
+   ExecStart=${HOME}/.local/bin/cdm-client
+   Restart=on-failure
+   RestartSec=3
+
+   [Install]
+   WantedBy=multi-user.target" | sudo tee /etc/systemd/system/cdm-client.service
+   ```
+
+2. Reload systemd and enable the service:
+   ```shell
+   sudo systemctl daemon-reload
+   sudo systemctl enable cdm-client.service
+   sudo systemctl start cdm-client.service
+   ```
+
+### Add automatic update (optional)
+To keep CDMClient updated automatically, you can add a cron job. Run:
+```shell
+crontab -e
+```
+Then add the following line to the crontab file:
+```shell
+0 3 * * * /usr/bin/python3 -m pip install --upgrade cdmclient --user && systemctl restart cdm-client.service
+```
+
+## Configuration
+The configuration file is located at:
+```~/.config/cdm_client/config.ini```
+
+This file is automatically generated when the service starts. Below is an example configuration:
+
+```ini
+[connection]
+server_host = "https://cdmserver.com"
+api_key = "1409d6ed79280aadcbe20f8f21981e89"
+client_host =
+client_port =
+client_username =
+client_password =
+client_type= transmission # possible values: transmission or qbitorrent
+```
+
+### Configuration Details:
+- **`server_host`**: The full URL of the CDM Server (e.g., `https://cdmserver.com`).
+- **`api_key`**: The API key generated when adding a new device on the CDM Server's devices page. Refer to the [Devices Page Documentation](../doc/USAGE.md#devices-page).
+- **`client_username`** and **`client_password`**: Required authentication for the selected torrent client.
+- **`client_type`**: Specify either `transmission` or `qbitorrent`, depending on the torrent client you are using.
+- **`client_host`** and **`client_port`**: Optional. If not specified, defaults to `localhost` and the default port for the selected client type.
+
+## Viewing Logs
+To monitor the service logs, use the following command:
+```shell
+journalctl -fu cdm-client
+```

cdmclient-1.2.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+cdm_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdm_client/cdm_client.py,sha256=CVu9MO9y09OZYRUL2bZHiokazeav7wDOk2pMGpv0i_w,9406
+cdm_client/config.py,sha256=rHxgcu3QTNly5ISgSvJmbSNoqhFXW722iin2B8Gwb0U,3001
+cdm_client/database_adapter.py,sha256=UGln3g4tiywaN7og9k2p7VEXIW094gyzQzLnDZhVUco,3428
+cdm_client/qbittorrent_adapter.py,sha256=8lZRnRs4WB-qmaVGH_hL1_LfvnO9GWbR0J5txNMQQTc,5236
+cdm_client/torrent_client_adapter_base.py,sha256=d-wP64gnzQw5dHNJ354JH-wrbF4ui83FDcljA5JG-_U,753
+cdm_client/torrent_client_factory.py,sha256=1NWDXEfuy1Zf2_Exo1FQ_Nvw8wF7TS5JswJvKjOXs48,1766
+cdm_client/transmission_adapter.py,sha256=3EvdioQ1ImPyhR30B4wtWP2WsjkTwVODP2pKcxlgmoA,2203
+cdmclient-1.2.4.dist-info/METADATA,sha256=fyo9zkaulJhpShDVzEj2c7Tpzm4HAefyYvE7M2m8vvQ,4666
+cdmclient-1.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdmclient-1.2.4.dist-info/entry_points.txt,sha256=cbr164wsAg2ll7-lMsGQxjkVfk9rQI83nq_Fub1Xsl0,58
+cdmclient-1.2.4.dist-info/licenses/LICENSE,sha256=yXUdXegqLKZ48VoEPZ-YYje08vmKRdB3C2Xh6IA8HLU,1068
+cdmclient-1.2.4.dist-info/RECORD,,

cdmclient-1.2.4.dist-info/WHEEL

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

cdmclient-1.2.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cdm-client = cdm_client.cdm_client:main

cdmclient-1.2.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aron Radics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.