torsh 0.1.0__tar.gz

torsh-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: torsh
+Version: 0.1.0
+Summary: Transmission TUI client
+Author: torsh authors
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=0.60.0
+Requires-Dist: transmission-rpc>=4.4.3
+Requires-Dist: click>=8.1.7
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: humanize>=4.9.0
+
+# torsh — Transmission TUI
+
+One-command Transmission client (btop-style). Runs `torsh`; it will start Transmission (and can auto-install it) or connect to an existing RPC.
+
+## Install
+- pipx (recommended): `pipx install torsh`
+- pip: `python3 -m pip install torsh`
+
+Needs Python 3.10+. If `transmission-daemon` is missing, torsh will try to install it via the available package manager (can be disabled).
+
+## Run
+```bash
+torsh
+# optional:
+# torsh --host localhost --port 9091 --download-dir ~/Downloads/torrents --no-autostart --no-install-missing
+```
+
+## Keys
+- `a` add magnet/.torrent (choose download dir)
+- `space` pause/resume
+- `d` delete (ask about data)
+- `g` change download dir
+- `s` set speed limits
+- `p` set file priorities
+- `l` view daemon log (auto-refresh tail)
+- `/` filter by name, `]`/`[` adjust refresh rate, `r` manual refresh
+- `?` help, `q` quit
+- UI remembers filters/sort/refresh interval between sessions.
+
+## Config
+Auto-created at `~/.config/torsh/config.yaml`. Env/flags override:
+`TORSH_HOST`, `TORSH_PORT`, `TORSH_USER`, `TORSH_PASSWORD`, `TORSH_TIMEOUT`,
+`TORSH_DOWNLOAD_DIR`, `TORSH_INSTALL_MISSING`, `TORSH_RESTART_ON_FAIL`, `TORSH_LOG`.
+
+Packaging notes: see `PACKAGING.md` (sdist/wheel, deb/rpm via fpm, brew formula template).
+
+## License
+MIT.

torsh-0.1.0/README.md

@@ -0,0 +1,38 @@
+# torsh — Transmission TUI
+
+One-command Transmission client (btop-style). Runs `torsh`; it will start Transmission (and can auto-install it) or connect to an existing RPC.
+
+## Install
+- pipx (recommended): `pipx install torsh`
+- pip: `python3 -m pip install torsh`
+
+Needs Python 3.10+. If `transmission-daemon` is missing, torsh will try to install it via the available package manager (can be disabled).
+
+## Run
+```bash
+torsh
+# optional:
+# torsh --host localhost --port 9091 --download-dir ~/Downloads/torrents --no-autostart --no-install-missing
+```
+
+## Keys
+- `a` add magnet/.torrent (choose download dir)
+- `space` pause/resume
+- `d` delete (ask about data)
+- `g` change download dir
+- `s` set speed limits
+- `p` set file priorities
+- `l` view daemon log (auto-refresh tail)
+- `/` filter by name, `]`/`[` adjust refresh rate, `r` manual refresh
+- `?` help, `q` quit
+- UI remembers filters/sort/refresh interval between sessions.
+
+## Config
+Auto-created at `~/.config/torsh/config.yaml`. Env/flags override:
+`TORSH_HOST`, `TORSH_PORT`, `TORSH_USER`, `TORSH_PASSWORD`, `TORSH_TIMEOUT`,
+`TORSH_DOWNLOAD_DIR`, `TORSH_INSTALL_MISSING`, `TORSH_RESTART_ON_FAIL`, `TORSH_LOG`.
+
+Packaging notes: see `PACKAGING.md` (sdist/wheel, deb/rpm via fpm, brew formula template).
+
+## License
+MIT.

torsh-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "torsh"
+version = "0.1.0"
+description = "Transmission TUI client"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "torsh authors" }]
+dependencies = [
+    "textual>=0.60.0",
+    "transmission-rpc>=4.4.3",
+    "click>=8.1.7",
+    "pyyaml>=6.0.1",
+    "humanize>=4.9.0",
+]
+
+[project.scripts]
+torsh = "torsh.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+exclude = ["tests*"]
+
+[tool.setuptools.package-data]
+"torsh.ui" = ["styles.tcss"]
+
+

torsh-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

torsh-0.1.0/torsh/__init__.py

@@ -0,0 +1,5 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"
+
+

torsh-0.1.0/torsh/cli.py

@@ -0,0 +1,62 @@
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from . import __version__
+from .config import AppConfig, load_config, save_config
+from .daemon import maybe_start_daemon
+from .logging import get_logger
+from .ui.app import TorshApp
+
+
+LOG = get_logger(__name__)
+
+
+def _apply_overrides(config: AppConfig, host: str, port: int, user: str | None, password: str | None, download_dir: str | None):
+    if host:
+        config.rpc.host = host
+    if port is not None:
+        config.rpc.port = port
+    if user is not None:
+        config.rpc.username = user
+    if password is not None:
+        config.rpc.password = password
+    if download_dir:
+        config.paths.download_dir = Path(download_dir).expanduser()
+    save_config(config)
+    return config
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option("--host", default=None, help="Transmission RPC host (default: localhost)")
+@click.option("--port", default=None, type=int, help="RPC port (default: 9091)")
+@click.option("--user", default=None, help="RPC username")
+@click.option("--password", default=None, help="RPC password")
+@click.option("--download-dir", default=None, help="Default download directory")
+@click.option("--no-autostart", is_flag=True, help="Do not auto-start transmission-daemon")
+@click.option("--no-install-missing", is_flag=True, help="Skip auto-install of transmission")
+@click.version_option(__version__, "-v", "--version", message="torsh %(version)s")
+def main(host: Optional[str], port: Optional[int], user: Optional[str], password: Optional[str], download_dir: Optional[str], no_autostart: bool, no_install_missing: bool):
+    """Run torsh TUI."""
+    config = load_config()
+    config = _apply_overrides(config, host, port, user, password, download_dir)
+    if no_autostart:
+        config.daemon.autostart = False
+    if no_install_missing:
+        config.daemon.install_missing = False
+
+    maybe_start_daemon(config)
+
+    app = TorshApp(config=config)
+    try:
+        asyncio.run(app.run_async())
+    except KeyboardInterrupt:
+        LOG.info("Interrupted by user (Ctrl+C)")
+
+
+if __name__ == "__main__":
+    main()
+
+

torsh-0.1.0/torsh/client.py

@@ -0,0 +1,175 @@
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Iterable, List, Optional
+
+import humanize
+from transmission_rpc import Client, TransmissionError, Torrent
+
+from .config import AppConfig
+from .logging import get_logger
+
+
+LOG = get_logger(__name__)
+
+
+@dataclass
+class TorrentView:
+    id: int
+    name: str
+    percent_done: float
+    status: str
+    eta: str
+    rate_down: str
+    rate_up: str
+    ratio: float
+    size: str
+    added: datetime | None
+    download_dir: str
+    peers: int
+    seeders: int
+    leechers: int
+
+
+class TransmissionController:
+    def __init__(self, config: AppConfig):
+        self.config = config
+        self._client: Client | None = None
+
+    @property
+    def client(self) -> Client:
+        if self._client is None:
+            self._client = Client(
+                host=self.config.rpc.host,
+                port=self.config.rpc.port,
+                username=self.config.rpc.username,
+                password=self.config.rpc.password,
+                timeout=self.config.rpc.timeout,
+            )
+        return self._client
+
+    def reset(self) -> None:
+        self._client = None
+
+    async def _to_thread(self, func, *args, **kwargs):
+        return await asyncio.to_thread(func, *args, **kwargs)
+
+    async def ensure_connected(self) -> None:
+        try:
+            await self._to_thread(self.client.get_session)
+        except TransmissionError:
+            self.reset()
+            raise
+        except Exception:
+            self.reset()
+            raise
+
+    async def list_torrents(self) -> List[TorrentView]:
+        torrents = await self._to_thread(self.client.get_torrents)
+        views: list[TorrentView] = []
+        for t in torrents:
+            views.append(self._map_torrent(t))
+        return views
+
+    async def session_stats(self):
+        return await self._to_thread(self.client.get_session_stats)
+
+    async def add(self, link: str, download_dir: Optional[str] = None) -> Torrent:
+        return await self._to_thread(
+            self.client.add_torrent,
+            link,
+            download_dir=download_dir or str(self.config.paths.download_dir),
+        )
+
+    async def start(self, ids: Iterable[int]):
+        return await self._to_thread(self.client.start_torrent, ids)
+
+    async def stop(self, ids: Iterable[int]):
+        return await self._to_thread(self.client.stop_torrent, ids)
+
+    async def remove(self, ids: Iterable[int], delete_data: bool = False):
+        return await self._to_thread(self.client.remove_torrent, ids, delete_data=delete_data)
+
+    async def move(self, ids: Iterable[int], location: str, move_data: bool = True):
+        return await self._to_thread(self.client.move_torrent_data, ids, location=location, move=move_data)
+
+    async def verify(self, ids: Iterable[int]):
+        return await self._to_thread(self.client.verify_torrent, ids)
+
+    async def get_speed_limits(self) -> dict:
+        session = await self._to_thread(self.client.get_session)
+        return {
+            "down": session.download_speed_limit if session.speed_limit_down_enabled else 0,
+            "up": session.upload_speed_limit if session.speed_limit_up_enabled else 0,
+        }
+
+    async def set_speed_limits(self, down_kib: int | None, up_kib: int | None):
+        kwargs = {}
+        if down_kib is not None:
+            kwargs["speed_limit_down_enabled"] = down_kib > 0
+            kwargs["download_speed_limit"] = max(0, down_kib)
+        if up_kib is not None:
+            kwargs["speed_limit_up_enabled"] = up_kib > 0
+            kwargs["upload_speed_limit"] = max(0, up_kib)
+        if kwargs:
+            await self._to_thread(self.client.set_session, **kwargs)
+
+    async def get_files(self, torrent_id: int) -> dict[int, dict]:
+        torrent = await self._to_thread(self.client.get_torrent, torrent_id)
+        files_attr = getattr(torrent, "files", {})
+        files = files_attr() if callable(files_attr) else files_attr  # type: ignore[misc]
+        return files or {}
+
+    async def set_priority(self, torrent_id: int, high: list[int], normal: list[int], low: list[int]):
+        await self._to_thread(
+            self.client.set_torrent,
+            torrent_id,
+            priority_high=high or None,
+            priority_normal=normal or None,
+            priority_low=low or None,
+        )
+
+    async def set_torrent_speed(self, torrent_id: int, down_kib: int | None, up_kib: int | None):
+        kwargs = {}
+        if down_kib is not None:
+            kwargs["downloadLimit"] = max(0, down_kib)
+            kwargs["downloadLimited"] = down_kib > 0
+        if up_kib is not None:
+            kwargs["uploadLimit"] = max(0, up_kib)
+            kwargs["uploadLimited"] = up_kib > 0
+        if kwargs:
+            await self._to_thread(self.client.set_torrent, torrent_id, **kwargs)
+
+    async def get_torrent_speed(self, torrent_id: int) -> dict[str, int]:
+        torrent = await self._to_thread(self.client.get_torrent, torrent_id)
+        down = getattr(torrent, "download_limit", 0) or 0
+        up = getattr(torrent, "upload_limit", 0) or 0
+        if getattr(torrent, "download_limited", False) is False:
+            down = 0
+        if getattr(torrent, "upload_limited", False) is False:
+            up = 0
+        return {"down": int(down), "up": int(up)}
+
+    def _map_torrent(self, t: Torrent) -> TorrentView:
+        eta = "—"
+        if t.eta and t.eta > 0:
+            eta = humanize.naturaldelta(t.eta)
+
+        return TorrentView(
+            id=t.id,
+            name=t.name,
+            percent_done=float(t.progress),
+            status=str(t.status),
+            eta=eta,
+            rate_down=humanize.naturalsize(t.rate_download) + "/s",
+            rate_up=humanize.naturalsize(t.rate_upload) + "/s",
+            ratio=float(t.ratio or 0),
+            size=humanize.naturalsize(t.total_size or 0),
+            added=t.date_added,
+            download_dir=t.download_dir,
+            peers=len(t.peers) if t.peers else 0,
+            seeders=t.seeders or 0,
+            leechers=t.leechers or 0,
+        )
+
+

torsh-0.1.0/torsh/config.py

@@ -0,0 +1,139 @@
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict
+
+import yaml
+
+
+CONFIG_DIR = Path(os.environ.get("TORSH_CONFIG_DIR", "~/.config/torsh")).expanduser()
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+
+@dataclass
+class RpcConfig:
+    host: str = os.environ.get("TORSH_HOST", "localhost")
+    port: int = int(os.environ.get("TORSH_PORT", "9091"))
+    username: str | None = os.environ.get("TORSH_USER") or None
+    password: str | None = os.environ.get("TORSH_PASSWORD") or None
+    timeout: float = float(os.environ.get("TORSH_TIMEOUT", "10.0"))
+
+
+@dataclass
+class DaemonConfig:
+    autostart: bool = os.environ.get("TORSH_AUTOSTART", "true").lower() != "false"
+    binary: str = os.environ.get("TORSH_DAEMON", "transmission-daemon")
+    extra_args: list[str] = field(default_factory=list)
+    install_missing: bool = os.environ.get("TORSH_INSTALL_MISSING", "true").lower() != "false"
+    restart_on_fail: bool = os.environ.get("TORSH_RESTART_ON_FAIL", "true").lower() != "false"
+    log_path: Path = Path(os.environ.get("TORSH_LOG", "") or (CONFIG_DIR / "daemon.log")).expanduser()
+
+
+@dataclass
+class PathConfig:
+    download_dir: Path = Path(os.environ.get("TORSH_DOWNLOAD_DIR", "~/Downloads/torrents")).expanduser()
+    config_dir: Path = CONFIG_DIR
+
+
+@dataclass
+class UIConfig:
+    refresh_interval: float = 2.5
+    sort_column: int | None = None
+    sort_desc: bool = False
+    filter_text: str = ""
+    status_filter: str = "any"
+    progress_filter: str = "any"
+
+
+@dataclass
+class AppConfig:
+    rpc: RpcConfig = field(default_factory=RpcConfig)
+    daemon: DaemonConfig = field(default_factory=DaemonConfig)
+    paths: PathConfig = field(default_factory=PathConfig)
+    ui: UIConfig = field(default_factory=UIConfig)
+
+
+def ensure_config_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> AppConfig:
+    ensure_config_dir()
+    if CONFIG_FILE.exists():
+        data = yaml.safe_load(CONFIG_FILE.read_text()) or {}
+    else:
+        data = {}
+
+    rpc_data: Dict[str, Any] = data.get("rpc", {})
+    daemon_data: Dict[str, Any] = data.get("daemon", {})
+    paths_data: Dict[str, Any] = data.get("paths", {})
+    ui_data: Dict[str, Any] = data.get("ui", {})
+
+    config = AppConfig(
+        rpc=RpcConfig(
+            host=rpc_data.get("host", RpcConfig().host),
+            port=int(rpc_data.get("port", RpcConfig().port)),
+            username=rpc_data.get("username", RpcConfig().username),
+            password=rpc_data.get("password", RpcConfig().password),
+            timeout=float(rpc_data.get("timeout", RpcConfig().timeout)),
+        ),
+        daemon=DaemonConfig(
+            autostart=bool(daemon_data.get("autostart", DaemonConfig().autostart)),
+            binary=daemon_data.get("binary", DaemonConfig().binary),
+            extra_args=daemon_data.get("extra_args", DaemonConfig().extra_args),
+            install_missing=bool(daemon_data.get("install_missing", DaemonConfig().install_missing)),
+            restart_on_fail=bool(daemon_data.get("restart_on_fail", DaemonConfig().restart_on_fail)),
+            log_path=Path(daemon_data.get("log_path", DaemonConfig().log_path)).expanduser(),
+        ),
+        paths=PathConfig(
+            download_dir=Path(paths_data.get("download_dir", PathConfig().download_dir)).expanduser(),
+            config_dir=Path(paths_data.get("config_dir", PathConfig().config_dir)).expanduser(),
+        ),
+        ui=UIConfig(
+            refresh_interval=float(ui_data.get("refresh_interval", UIConfig().refresh_interval)),
+            sort_column=ui_data.get("sort_column", UIConfig().sort_column),
+            sort_desc=bool(ui_data.get("sort_desc", UIConfig().sort_desc)),
+            filter_text=ui_data.get("filter_text", UIConfig().filter_text),
+            status_filter=ui_data.get("status_filter", UIConfig().status_filter),
+            progress_filter=ui_data.get("progress_filter", UIConfig().progress_filter),
+        ),
+    )
+
+    save_config(config)
+    return config
+
+
+def save_config(config: AppConfig) -> None:
+    ensure_config_dir()
+    payload = {
+        "rpc": {
+            "host": config.rpc.host,
+            "port": config.rpc.port,
+            "username": config.rpc.username or "",
+            "password": config.rpc.password or "",
+            "timeout": config.rpc.timeout,
+        },
+        "daemon": {
+            "autostart": config.daemon.autostart,
+            "binary": config.daemon.binary,
+            "extra_args": config.daemon.extra_args,
+            "install_missing": config.daemon.install_missing,
+            "restart_on_fail": config.daemon.restart_on_fail,
+            "log_path": str(config.daemon.log_path),
+        },
+        "paths": {
+            "download_dir": str(config.paths.download_dir),
+            "config_dir": str(config.paths.config_dir),
+        },
+        "ui": {
+            "refresh_interval": config.ui.refresh_interval,
+            "sort_column": config.ui.sort_column,
+            "sort_desc": config.ui.sort_desc,
+            "filter_text": config.ui.filter_text,
+            "status_filter": config.ui.status_filter,
+            "progress_filter": config.ui.progress_filter,
+        },
+    }
+    CONFIG_FILE.write_text(yaml.safe_dump(payload, sort_keys=False, allow_unicode=False))
+
+

torsh-0.1.0/torsh/daemon.py

@@ -0,0 +1,158 @@
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Iterable
+
+from .config import AppConfig
+from .logging import get_logger
+
+
+LOG = get_logger(__name__)
+
+
+def _is_daemon_running() -> bool:
+    try:
+        result = subprocess.run(
+            ["pgrep", "-x", "transmission-daemon"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            check=False,
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
+
+
+def _detect_package_manager() -> str | None:
+    managers = ["apt-get", "apt", "brew", "dnf", "yum", "pacman", "zypper"]
+    for mgr in managers:
+        if shutil.which(mgr):
+            return mgr
+    return None
+
+
+def _install_transmission(manager: str) -> bool:
+    commands = {
+        "apt-get": ["sudo", "apt-get", "update", "&&", "sudo", "apt-get", "-y", "install", "transmission-daemon"],
+        "apt": ["sudo", "apt", "update", "&&", "sudo", "apt", "-y", "install", "transmission-daemon"],
+        "brew": ["brew", "install", "transmission"],
+        "dnf": ["sudo", "dnf", "-y", "install", "transmission-daemon"],
+        "yum": ["sudo", "yum", "-y", "install", "transmission-daemon"],
+        "pacman": ["sudo", "pacman", "-Sy", "--noconfirm", "transmission-cli"],
+        "zypper": ["sudo", "zypper", "--non-interactive", "install", "transmission-daemon"],
+    }
+    cmd = commands.get(manager)
+    if not cmd:
+        return False
+    LOG.info("Trying to install transmission via %s", manager)
+    try:
+        # emulate '&&' without shell
+        if "&&" in cmd:
+            # apt/apt-get branch
+            update = cmd[:3]
+            install = cmd[4:]
+            subprocess.run(update, check=False)
+            result = subprocess.run(install, check=False)
+        else:
+            result = subprocess.run(cmd, check=False)
+        return result.returncode == 0
+    except Exception as exc:  # pragma: no cover - safeguard
+        LOG.error("Auto-install failed: %s", exc)
+        return False
+
+
+def ensure_transmission_available(config: AppConfig) -> bool:
+    """Ensure transmission binary exists; optionally try to install it."""
+    if shutil.which(config.daemon.binary):
+        return True
+    if not config.daemon.install_missing:
+        LOG.warning("Binary %s not found, auto-install is disabled", config.daemon.binary)
+        return False
+
+    mgr = _detect_package_manager()
+    if not mgr:
+        LOG.warning("No supported package manager found for auto-install")
+        return False
+
+    ok = _install_transmission(mgr)
+    if not ok:
+        LOG.warning("Auto-install via %s failed", mgr)
+        return False
+
+    return shutil.which(config.daemon.binary) is not None
+
+
+def _build_daemon_args(config: AppConfig) -> list[str]:
+    cfg_dir = config.paths.config_dir
+    download_dir = config.paths.download_dir
+    cfg_dir.mkdir(parents=True, exist_ok=True)
+    download_dir.mkdir(parents=True, exist_ok=True)
+
+    args = [
+        config.daemon.binary,
+        "--foreground",
+        "--config-dir",
+        str(cfg_dir),
+        "--download-dir",
+        str(download_dir),
+        "--log-info",
+    ]
+    args.extend(config.daemon.extra_args or [])
+    return args
+
+
+def maybe_start_daemon(config: AppConfig, wait_seconds: float = 2.5) -> None:
+    if not config.daemon.autostart:
+        LOG.info("Daemon autostart disabled")
+        return
+
+    if not ensure_transmission_available(config):
+        LOG.error("Transmission unavailable. Install manually or enable auto-install.")
+        return
+
+    if _is_daemon_running():
+        LOG.debug("transmission-daemon is already running")
+        return
+
+    binary = shutil.which(config.daemon.binary)
+    if not binary:
+        LOG.warning("Binary transmission-daemon not found: %s", config.daemon.binary)
+        return
+
+    args = _build_daemon_args(config)
+    log_file = config.daemon.log_path
+    log_file.parent.mkdir(parents=True, exist_ok=True)
+    log = log_file.open("a", encoding="utf-8")
+
+    LOG.info("Starting transmission-daemon: %s", " ".join(args))
+    try:
+        subprocess.Popen(
+            args,
+            stdout=log,
+            stderr=log,
+            close_fds=True,
+            start_new_session=True,
+        )
+    except Exception as exc:  # pragma: no cover - safeguard
+        LOG.error("Failed to start transmission-daemon: %s", exc)
+        return
+
+    # give daemon time to start
+    time.sleep(wait_seconds)
+
+
+def stop_daemon(process_names: Iterable[str] = ("transmission-daemon",)) -> None:
+    for name in process_names:
+        try:
+            subprocess.run(["pkill", "-x", name], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except FileNotFoundError:
+            LOG.debug("pkill is not available on this system")
+            break
+
+    # small delay to let daemon exit
+    time.sleep(0.5)
+
+