plex-tui 0.2.0__py3-none-any.whl

plextui/artwork.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import hashlib
+import os
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlencode, urlsplit, urlunsplit
+from urllib.request import Request, urlopen
+
+from PIL import Image, ImageOps
+from rich.text import Text
+
+from .config import AppConfig, cache_path
+
+
+MAX_IMAGE_BYTES = 12 * 1024 * 1024
+ARTWORK_CACHE_LIMIT_BYTES = 100 * 1024 * 1024
+NATIVE_IMAGE_ENV = "PLEX_TUI_ENABLE_NATIVE_IMAGES"
+
+
+def fetch_artwork(raw: Any, path: str, config: AppConfig) -> bytes:
+    cached = cached_artwork_path(path, config)
+    if cached.exists():
+        return cached.read_bytes()
+
+    url = artwork_url(raw, path, config)
+    request = Request(url, headers={"User-Agent": "plex-tui"})
+    with urlopen(request, timeout=10) as response:
+        status = getattr(response, "status", 200)
+        if status != 200:
+            raise OSError(f"artwork fetch failed: HTTP {status}")
+        data = response.read(MAX_IMAGE_BYTES + 1)
+    if len(data) > MAX_IMAGE_BYTES:
+        raise OSError("artwork image is too large")
+
+    cached.parent.mkdir(parents=True, exist_ok=True)
+    cached.write_bytes(data)
+    prune_artwork_cache()
+    return data
+
+
+def artwork_url(raw: Any, path: str, config: AppConfig) -> str:
+    server = getattr(raw, "_server", None)
+    if server is not None and hasattr(server, "url"):
+        try:
+            return str(server.url(path, includeToken=True))
+        except Exception:
+            pass
+
+    if path.startswith("http://") or path.startswith("https://"):
+        url = path
+    else:
+        url = f"{config.base_url.rstrip('/')}/{path.lstrip('/')}"
+    return add_token(url, config.token)
+
+
+def add_token(url: str, token: str) -> str:
+    if not token:
+        return url
+    parts = urlsplit(url)
+    query = parts.query
+    separator = "&" if query else ""
+    query = f"{query}{separator}{urlencode({'X-Plex-Token': token})}"
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, query, parts.fragment))
+
+
+def cached_artwork_path(path: str, config: AppConfig) -> Path:
+    key = hashlib.sha256(f"{config.base_url}\0{path}".encode("utf-8")).hexdigest()
+    return cache_path() / "artwork" / f"{key}.img"
+
+
+def artwork_is_cached(path: str, config: AppConfig) -> bool:
+    return cached_artwork_path(path, config).exists()
+
+
+def prune_artwork_cache(limit_bytes: int = ARTWORK_CACHE_LIMIT_BYTES) -> None:
+    directory = cache_path() / "artwork"
+    if not directory.exists():
+        return
+    files = []
+    total = 0
+    try:
+        for path in directory.iterdir():
+            if not path.is_file():
+                continue
+            stat = path.stat()
+            files.append((stat.st_mtime, stat.st_size, path))
+            total += stat.st_size
+    except OSError:
+        return
+    if total <= limit_bytes:
+        return
+    for _, size, path in sorted(files):
+        try:
+            path.unlink()
+        except OSError:
+            continue
+        total -= size
+        if total <= limit_bytes:
+            break
+
+
+def render_artwork(data: bytes, width: int = 28, max_height: int = 20) -> Text:
+    image = load_image(data)
+    image = resize_for_cells(image, width, max_height)
+
+    text = Text()
+    pixels = image.load()
+    for y in range(0, image.height, 2):
+        for x in range(image.width):
+            top = pixels[x, y]
+            bottom = pixels[x, y + 1] if y + 1 < image.height else top
+            text.append("▀", style=f"{rgb(top)} on {rgb(bottom)}")
+        if y + 2 < image.height:
+            text.append("\n")
+    return text
+
+
+def render_protocol_artwork(data: bytes, renderer: str, width: int = 28, max_height: int = 20) -> object | None:
+    return None
+
+
+def resolve_protocol_renderer(renderer: str) -> str:
+    if not native_images_enabled():
+        return "block"
+    if renderer == "kitty":
+        return "kitty"
+    if renderer == "auto" and is_kitty_terminal():
+        return "kitty"
+    return "block"
+
+
+def native_images_enabled() -> bool:
+    return os.environ.get(NATIVE_IMAGE_ENV) == "1"
+
+
+def is_kitty_terminal() -> bool:
+    return bool(os.environ.get("KITTY_WINDOW_ID") or "kitty" in os.environ.get("TERM", "").lower())
+
+
+def load_image(data: bytes) -> Image.Image:
+    return ImageOps.exif_transpose(Image.open(BytesIO(data))).convert("RGB")
+
+
+def resize_for_cells(image: Image.Image, width: int, max_height: int) -> Image.Image:
+    source_width, source_height = image.size
+    if not source_width or not source_height:
+        return Image.new("RGB", (1, 2), "#000000")
+
+    width = max(1, width)
+    max_height = max(1, max_height)
+    pixel_height = min(max_height * 2, max(2, round(source_height / source_width * width * 2)))
+    return ImageOps.contain(image, (width, pixel_height), Image.Resampling.LANCZOS)
+
+
+def rgb(color: tuple[int, int, int]) -> str:
+    return f"#{color[0]:02x}{color[1]:02x}{color[2]:02x}"

plextui/auth.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import webbrowser
+from dataclasses import dataclass
+
+from plexapi.myplex import MyPlexAccount, MyPlexPinLogin, MyPlexResource
+
+from . import __version__
+from .config import APP_NAME, AppConfig, save_config
+
+
+@dataclass(frozen=True)
+class ServerChoice:
+    name: str
+    uri: str
+    source: str
+    resource: MyPlexResource
+
+
+class LoginSession:
+    def __init__(self, config: AppConfig) -> None:
+        self.config = config
+        self.pin_login = MyPlexPinLogin(headers=plex_headers(config), oauth=True)
+
+    def start(self, timeout: int = 300) -> str:
+        self.pin_login.run(timeout=timeout)
+        url = self.pin_login.oauthUrl()
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass
+        return url
+
+    def wait(self) -> tuple[str, list[ServerChoice]]:
+        if not self.pin_login.waitForLogin() or not self.pin_login.token:
+            raise RuntimeError("Plex login timed out or was cancelled")
+
+        account_token = self.pin_login.token
+        account = MyPlexAccount(token=account_token)
+        choices: list[ServerChoice] = []
+        for resource in account.resources():
+            if "server" not in str(resource.provides):
+                continue
+            for uri in resource.preferred_connections():
+                choices.append(
+                    ServerChoice(
+                        name=resource.name,
+                        uri=uri,
+                        source=resource.sourceTitle or "owned",
+                        resource=resource,
+                    )
+                )
+        if not choices:
+            raise RuntimeError("No Plex Media Server resources found for this account")
+        return account_token, choices
+
+    def stop(self) -> None:
+        self.pin_login.stop()
+
+
+def save_server_choice(config: AppConfig, account_token: str, choice: ServerChoice) -> AppConfig:
+    saved = AppConfig(
+        base_url=choice.uri,
+        token=choice.resource.accessToken,
+        client_identifier=config.client_identifier,
+        account_token=account_token,
+        preferred_audio_language=config.preferred_audio_language,
+        preferred_subtitle_language=config.preferred_subtitle_language,
+        subtitle_mode=config.subtitle_mode,
+        artwork_mode=config.artwork_mode,
+        artwork_renderer=config.artwork_renderer,
+        detail_artwork_mode=config.detail_artwork_mode,
+        grid_density=config.grid_density,
+        media_view=config.media_view,
+        theme=config.theme,
+        mpv_window_size=config.mpv_window_size,
+        page_size=config.page_size,
+        auto_load_threshold=config.auto_load_threshold,
+    )
+    save_config(saved)
+    return saved
+
+
+def plex_headers(config: AppConfig) -> dict[str, str]:
+    return {
+        "X-Plex-Product": APP_NAME,
+        "X-Plex-Version": __version__,
+        "X-Plex-Client-Identifier": config.client_identifier,
+        "X-Plex-Platform": "Python",
+        "X-Plex-Platform-Version": "3",
+        "X-Plex-Device": "terminal",
+        "X-Plex-Device-Name": APP_NAME,
+    }

plextui/config.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import os
+import re
+import tomllib
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+
+from platformdirs import user_cache_dir, user_config_dir
+
+
+APP_NAME = "plex-tui"
+DEFAULT_PAGE_SIZE = 40
+MIN_PAGE_SIZE = 25
+MAX_PAGE_SIZE = 500
+DEFAULT_AUTO_LOAD_THRESHOLD = 10
+MIN_AUTO_LOAD_THRESHOLD = 1
+MAX_AUTO_LOAD_THRESHOLD = 100
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    base_url: str
+    token: str
+    client_identifier: str
+    account_token: str = ""
+    preferred_audio_language: str = ""
+    preferred_subtitle_language: str = ""
+    subtitle_mode: str = "auto"
+    artwork_mode: str = "on"
+    artwork_renderer: str = "block"
+    detail_artwork_mode: str = "list_only"
+    grid_density: str = "comfortable"
+    media_view: str = "list"
+    theme: str = "textual-dark"
+    mpv_window_size: str = ""
+    page_size: int = DEFAULT_PAGE_SIZE
+    auto_load_threshold: int = DEFAULT_AUTO_LOAD_THRESHOLD
+
+
+def config_path() -> Path:
+    return Path(user_config_dir(APP_NAME)) / "config.toml"
+
+
+def cache_path() -> Path:
+    return Path(user_cache_dir(APP_NAME))
+
+
+def debug_log_path() -> Path:
+    return Path(user_config_dir(APP_NAME)) / "debug.log"
+
+
+def load_config() -> AppConfig:
+    data: dict[str, str] = {}
+    path = config_path()
+    if path.exists():
+        with path.open("rb") as fh:
+            raw = tomllib.load(fh)
+        data = {k: str(v) for k, v in raw.items() if isinstance(v, str | int)}
+
+    base_url = os.environ.get("PLEX_TUI_BASE_URL") or data.get("base_url", "")
+    token = os.environ.get("PLEX_TUI_TOKEN") or data.get("token", "")
+    client_identifier = data.get("client_identifier") or f"plex-tui-{uuid.uuid4()}"
+    account_token = data.get("account_token", "")
+    preferred_audio_language = data.get("preferred_audio_language", "")
+    preferred_subtitle_language = data.get("preferred_subtitle_language", "")
+    subtitle_mode = data.get("subtitle_mode", "auto")
+    if subtitle_mode not in {"auto", "none", "preferred"}:
+        write_debug_log(f"invalid subtitle_mode {subtitle_mode!r}; using 'auto'")
+        subtitle_mode = "auto"
+    artwork_mode = data.get("artwork_mode", "on")
+    if artwork_mode not in {"on", "off"}:
+        write_debug_log(f"invalid artwork_mode {artwork_mode!r}; using 'on'")
+        artwork_mode = "on"
+    artwork_renderer = data.get("artwork_renderer", "block")
+    if artwork_renderer not in {"block", "auto", "kitty"}:
+        write_debug_log(f"invalid artwork_renderer {artwork_renderer!r}; using 'block'")
+        artwork_renderer = "block"
+    detail_artwork_mode = data.get("detail_artwork_mode", "list_only")
+    if detail_artwork_mode not in {"list_only", "on", "off"}:
+        write_debug_log(f"invalid detail_artwork_mode {detail_artwork_mode!r}; using 'list_only'")
+        detail_artwork_mode = "list_only"
+    grid_density = data.get("grid_density", "comfortable")
+    if grid_density not in {"compact", "comfortable", "large"}:
+        write_debug_log(f"invalid grid_density {grid_density!r}; using 'comfortable'")
+        grid_density = "comfortable"
+    media_view = data.get("media_view", "list")
+    if media_view == "poster":
+        write_debug_log("media_view 'poster' is deprecated; using 'list'")
+        media_view = "list"
+    if media_view not in {"list", "grid"}:
+        write_debug_log(f"invalid media_view {media_view!r}; using 'list'")
+        media_view = "list"
+    theme = data.get("theme", "textual-dark")
+    mpv_window_size = data.get("mpv_window_size", "")
+    if mpv_window_size and not valid_mpv_window_size(mpv_window_size):
+        write_debug_log(f"invalid mpv_window_size {mpv_window_size!r}; using default")
+        mpv_window_size = ""
+    page_size = bounded_int(
+        data.get("page_size", ""),
+        DEFAULT_PAGE_SIZE,
+        MIN_PAGE_SIZE,
+        MAX_PAGE_SIZE,
+        "page_size",
+    )
+    auto_load_threshold = bounded_int(
+        data.get("auto_load_threshold", ""),
+        DEFAULT_AUTO_LOAD_THRESHOLD,
+        MIN_AUTO_LOAD_THRESHOLD,
+        MAX_AUTO_LOAD_THRESHOLD,
+        "auto_load_threshold",
+    )
+    return AppConfig(
+        base_url=base_url.strip(),
+        token=token.strip(),
+        client_identifier=client_identifier.strip(),
+        account_token=account_token.strip(),
+        preferred_audio_language=preferred_audio_language.strip(),
+        preferred_subtitle_language=preferred_subtitle_language.strip(),
+        subtitle_mode=subtitle_mode.strip(),
+        artwork_mode=artwork_mode.strip(),
+        artwork_renderer=artwork_renderer.strip(),
+        detail_artwork_mode=detail_artwork_mode.strip(),
+        grid_density=grid_density.strip(),
+        media_view=media_view.strip(),
+        theme=theme.strip() or "textual-dark",
+        mpv_window_size=mpv_window_size.strip(),
+        page_size=page_size,
+        auto_load_threshold=auto_load_threshold,
+    )
+
+
+def save_config(config: AppConfig) -> None:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    lines = [
+        f'base_url = "{_toml_escape(config.base_url)}"',
+        f'token = "{_toml_escape(config.token)}"',
+        f'client_identifier = "{_toml_escape(config.client_identifier)}"',
+    ]
+    if config.account_token:
+        lines.append(f'account_token = "{_toml_escape(config.account_token)}"')
+    if config.preferred_audio_language:
+        lines.append(f'preferred_audio_language = "{_toml_escape(config.preferred_audio_language)}"')
+    if config.preferred_subtitle_language:
+        lines.append(f'preferred_subtitle_language = "{_toml_escape(config.preferred_subtitle_language)}"')
+    if config.subtitle_mode != "auto":
+        lines.append(f'subtitle_mode = "{_toml_escape(config.subtitle_mode)}"')
+    if config.artwork_mode != "on":
+        lines.append(f'artwork_mode = "{_toml_escape(config.artwork_mode)}"')
+    if config.artwork_renderer != "block":
+        lines.append(f'artwork_renderer = "{_toml_escape(config.artwork_renderer)}"')
+    if config.detail_artwork_mode != "list_only":
+        lines.append(f'detail_artwork_mode = "{_toml_escape(config.detail_artwork_mode)}"')
+    if config.grid_density != "comfortable":
+        lines.append(f'grid_density = "{_toml_escape(config.grid_density)}"')
+    if config.media_view != "list":
+        lines.append(f'media_view = "{_toml_escape(config.media_view)}"')
+    if config.theme != "textual-dark":
+        lines.append(f'theme = "{_toml_escape(config.theme)}"')
+    if config.mpv_window_size:
+        lines.append(f'mpv_window_size = "{_toml_escape(config.mpv_window_size)}"')
+    if config.page_size != DEFAULT_PAGE_SIZE:
+        lines.append(f"page_size = {config.page_size}")
+    if config.auto_load_threshold != DEFAULT_AUTO_LOAD_THRESHOLD:
+        lines.append(f"auto_load_threshold = {config.auto_load_threshold}")
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def valid_mpv_window_size(value: str) -> bool:
+    return bool(re.fullmatch(r"(?:\d{2,5}x\d{2,5}|\d{1,3}%x\d{1,3}%|\d{1,3}%)", value.strip()))
+
+
+def bounded_int(value: str, default: int, minimum: int, maximum: int, name: str) -> int:
+    if value == "":
+        return default
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        write_debug_log(f"invalid {name} {value!r}; using {default}")
+        return default
+    if parsed < minimum or parsed > maximum:
+        write_debug_log(f"invalid {name} {value!r}; using {default}")
+        return default
+    return parsed
+
+
+def _toml_escape(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def write_debug_log(message: str) -> None:
+    try:
+        path = debug_log_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as fh:
+            fh.write(f"{message}\n")
+    except OSError:
+        return

plextui/models.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class LibraryItem:
+    title: str
+    key: str
+    kind: str
+    raw: Any
+
+
+@dataclass(frozen=True)
+class MediaItem:
+    title: str
+    subtitle: str
+    kind: str
+    key: str
+    playable: bool
+    raw: Any
+    artwork_path: str = ""
+
+
+@dataclass(frozen=True)
+class MediaDetails:
+    title: str
+    kind: str
+    facts: list[str]
+    metadata: list[tuple[str, str]]
+    audio: list[str]
+    subtitles: list[str]
+    summary: str
+    playable: bool
+    artwork_path: str = ""