emby-cli 0.1.0__py3-none-any.whl

emby_cli/commands/batch.py

@@ -0,0 +1,244 @@
+"""batch command — download titles from a text file."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import time
+from pathlib import Path
+
+from emby_cli.client import EmbyClient
+from emby_cli.download_ops import do_download, should_skip_item
+from emby_cli.resolve import (
+    classify_resolution,
+    item_video_width,
+    parse_title_line,
+    pick_best_item,
+)
+from emby_cli.util import (
+    build_dest_path,
+    format_duration,
+    format_size,
+    item_remote_size,
+)
+
+def cmd_batch(client: EmbyClient, args: argparse.Namespace) -> None:
+    """Download titles listed in a text file, with resolution prioritisation."""
+    output = Path(args.output)
+    throttle = getattr(args, "throttle", 0)
+    method = getattr(args, "method", "download")
+    dry_run = getattr(args, "dry_run", False)
+
+    if dry_run:
+        print("*** DRY RUN — no files will be downloaded ***\n")
+
+    file_path = Path(args.file)
+    lines: list[str] = []
+    with open(file_path) as f:
+        for raw in f:
+            raw = raw.strip()
+            if raw and not raw.startswith("#"):
+                lines.append(raw)
+
+    if not lines:
+        print("No titles found in file.")
+        return
+
+    print(f"Loaded {len(lines)} titles from {file_path}\n")
+
+    stats: list[tuple[str, str, float, str]] = []
+    total_t0 = time.monotonic()
+
+    for idx, raw_line in enumerate(lines, 1):
+        emby_id_match = re.match(r"^embyId=(\S+)$", raw_line.strip(), re.IGNORECASE)
+        if emby_id_match:
+            item_id = emby_id_match.group(1)
+            label = f"embyId={item_id}"
+            print(f"\n[{idx}/{len(lines)}] Direct ID: {item_id}")
+            line_t0 = time.monotonic()
+            try:
+                item = client.get_item_info(item_id)
+                res = classify_resolution(item_video_width(item))
+                size = format_size(item_remote_size(item))
+                dest = build_dest_path(item, output)
+                print(f"  {item['Name']} ({item.get('ProductionYear','?')}) [{res}, {size}]")
+
+                if dry_run:
+                    print(f"  Would download: {item['Name']} [{res}] -> {dest}")
+                    stats.append((label, "DRY RUN", 0, item['Name']))
+                    continue
+
+                if should_skip_item(item, dest, method, args.force):
+                    elapsed = time.monotonic() - line_t0
+                    print(f"  Skipping (already downloaded)")
+                    stats.append((label, "SKIPPED", elapsed, item['Name']))
+                    continue
+
+                print(f"  Downloading -> {dest}")
+                do_download(client, item_id, item, dest, method, throttle)
+                elapsed = time.monotonic() - line_t0
+                print(f"  Time: {format_duration(elapsed)}")
+                stats.append((label, "OK", elapsed, item['Name']))
+            except Exception as exc:
+                elapsed = time.monotonic() - line_t0
+                print(f"  ERROR: {exc}")
+                stats.append((label, "ERROR", elapsed, str(exc)))
+            continue
+
+        title, season, episode, year = parse_title_line(raw_line)
+
+        if season is not None:
+            kind = f"S{season:02d}E{episode:02d}" if episode else f"S{season:02d}"
+            label = f"{title} ({year}) {kind}" if year else f"{title} {kind}"
+            search_type = "series"
+        else:
+            label = f"{title} ({year})" if year else title
+            search_type = "movie"
+
+        print(f"\n[{idx}/{len(lines)}] Searching: \"{label}\" ({search_type})")
+        line_t0 = time.monotonic()
+
+        try:
+            if search_type == "movie":
+                results = client.search_items(title, item_types="Movie")
+                if not results:
+                    print("  No results found, skipping.")
+                    stats.append((label, "NOT FOUND", 0, ""))
+                    continue
+
+                candidates = results
+                if year is not None:
+                    year_matches = [r for r in results if r.get("ProductionYear") == year]
+                    if year_matches:
+                        print(f"  Year filter: {year} ({len(year_matches)}/{len(results)} match)")
+                        candidates = year_matches
+                    else:
+                      print(f"  WARNING: no results match year {year}, using all {len(results)} results")
+
+                best = pick_best_item(candidates)
+                for r in results:
+                    res = classify_resolution(item_video_width(r))
+                    size = format_size(item_remote_size(r))
+                    selected = " <-- selected" if r is best else ""
+                    excluded = " (excluded by year)" if year and r not in candidates else ""
+                    print(f"    - {r['Name']} ({r.get('ProductionYear','?')}) [{res}, {size}]{selected}{excluded}")
+
+                res = classify_resolution(item_video_width(best))
+                dest = build_dest_path(best, output)
+
+                if dry_run:
+                    print(f"  Would download: {best['Name']} [{res}] -> {dest}")
+                    stats.append((label, "DRY RUN", 0, ""))
+                    continue
+
+                if should_skip_item(best, dest, method, args.force):
+                    elapsed = time.monotonic() - line_t0
+                    print(f"  Skipping (already downloaded)")
+                    stats.append((label, "SKIPPED", elapsed, ""))
+                    continue
+
+                print(f"  Downloading: {best['Name']} [{res}] -> {dest}")
+                do_download(client, best["Id"], best, dest, method, throttle)
+                elapsed = time.monotonic() - line_t0
+                print(f"  Time: {format_duration(elapsed)}")
+                stats.append((label, "OK", elapsed, ""))
+
+            else:
+                series_results = client.search_items(title, item_types="Series")
+                if not series_results:
+                    print("  No series found, skipping.")
+                    stats.append((label, "NOT FOUND", 0, ""))
+                    continue
+
+                if year is not None:
+                    year_matches = [s for s in series_results if s.get("ProductionYear") == year]
+                    if year_matches:
+                        print(f"  Year filter: {year} ({len(year_matches)}/{len(series_results)} match)")
+                        for s in series_results:
+                            tag = " <-- selected" if s is year_matches[0] else ""
+                            excluded = " (excluded by year)" if s not in year_matches else ""
+                            print(f"    - {s['Name']} ({s.get('ProductionYear','?')}){tag}{excluded}")
+                        series = year_matches[0]
+                    else:
+                        print(f"  WARNING: no series match year {year}, using first result")
+                        series = series_results[0]
+                else:
+                    series = series_results[0]
+
+                print(f"  Found series: {series['Name']} ({series.get('ProductionYear','?')})")
+
+                episodes = client.get_show_episodes(series["Id"], season=season)
+                if episode is not None:
+                    episodes = [e for e in episodes if e.get("IndexNumber") == episode]
+
+                if not episodes:
+                    print(f"  No episodes found for {kind}, skipping.")
+                    stats.append((label, "NOT FOUND", 0, ""))
+                    continue
+
+                print(f"  {len(episodes)} episode(s)")
+
+                if dry_run:
+                    for ep_idx, ep in enumerate(episodes, 1):
+                        ep_num = f"S{ep.get('ParentIndexNumber', 0):02d}E{ep.get('IndexNumber', 0):02d}"
+                        ep_name = ep.get("Name", "?")
+                        res = classify_resolution(item_video_width(ep))
+                        size = format_size(item_remote_size(ep))
+                        print(f"  [{ep_idx}/{len(episodes)}] {ep_num} {ep_name} [{res}, {size}]")
+                    stats.append((label, "DRY RUN", 0, f"{len(episodes)} episodes"))
+                    continue
+
+                ep_errors = 0
+
+                for ep_idx, ep in enumerate(episodes, 1):
+                    ep_num = f"S{ep.get('ParentIndexNumber', 0):02d}E{ep.get('IndexNumber', 0):02d}"
+                    ep_name = ep.get("Name", "?")
+                    res = classify_resolution(item_video_width(ep))
+                    size = format_size(item_remote_size(ep))
+                    dest = build_dest_path(ep, output)
+
+                    if should_skip_item(ep, dest, method, args.force):
+                        print(f"  [{ep_idx}/{len(episodes)}] {ep_num} {ep_name} [{res}] - skipped")
+                        continue
+
+                    print(f"  [{ep_idx}/{len(episodes)}] {ep_num} {ep_name} [{res}, {size}]")
+                    try:
+                        do_download(client, ep["Id"], ep, dest, method, throttle)
+                    except Exception as exc:
+                        print(f"    ERROR: {exc}")
+                        ep_errors += 1
+
+                elapsed = time.monotonic() - line_t0
+                detail = f"{len(episodes)} episodes"
+                if ep_errors:
+                    detail += f", {ep_errors} errors"
+                status = "OK" if not ep_errors else "PARTIAL"
+                print(f"  Time: {format_duration(elapsed)}")
+                stats.append((label, status, elapsed, detail))
+
+        except Exception as exc:
+            elapsed = time.monotonic() - line_t0
+            print(f"  ERROR: {exc}")
+            stats.append((label, "ERROR", elapsed, str(exc)))
+
+    total_elapsed = time.monotonic() - total_t0
+
+    print(f"\n{'='*60}")
+    print(f"Batch complete in {format_duration(total_elapsed)}\n")
+
+    max_label = max(len(s[0]) for s in stats) if stats else 10
+    for label, status, elapsed, detail in stats:
+        time_str = format_duration(elapsed) if elapsed > 0 else "-"
+        detail_str = f" ({detail})" if detail else ""
+        dots = "." * (max_label - len(label) + 3)
+        print(f"  {label} {dots} {time_str:<10} {status}{detail_str}")
+
+    counts: dict[str, int] = {}
+    for _, status, _, _ in stats:
+        counts[status] = counts.get(status, 0) + 1
+
+    print(f"\nDownloaded: {counts.get('OK', 0)}, Skipped: {counts.get('SKIPPED', 0)}, "
+          f"Not found: {counts.get('NOT FOUND', 0)}, Errors: {counts.get('ERROR', 0)}")
+    if counts.get("PARTIAL"):
+        print(f"Partial: {counts['PARTIAL']}")
+    print(f"{'='*60}")

emby_cli/commands/download.py

@@ -0,0 +1,77 @@
+"""download command."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from emby_cli.client import EmbyClient
+from emby_cli.download_ops import do_download, should_skip_item
+from emby_cli.util import build_dest_path
+
+def cmd_download(client: EmbyClient, args: argparse.Namespace) -> None:
+    output = Path(args.output)
+    downloadable = ("Movie", "Episode", "Audio", "Video")
+    throttle = getattr(args, "throttle", False)
+    method = getattr(args, "method", "download")
+
+    if args.item_id:
+        item_ids = [x.strip() for x in args.item_id.split(",") if x.strip()]
+        total = len(item_ids)
+        errors = 0
+        for idx, iid in enumerate(item_ids, 1):
+            prefix = f"[{idx}/{total}]" if total > 1 else ""
+            try:
+                item = client.get_item_info(iid)
+            except Exception as exc:
+                print(f"{prefix} ERROR fetching item {iid}: {exc}")
+                errors += 1
+                continue
+            dest = build_dest_path(item, output)
+            if should_skip_item(item, dest, method, args.force):
+                print(f"{prefix} Skipping (already downloaded): {dest}")
+                continue
+            print(f"{prefix} Downloading ({method}): {item['Name']} -> {dest}")
+            try:
+                do_download(client, iid, item, dest, method, throttle)
+            except Exception as exc:
+                print(f"  ERROR: {exc}")
+                errors += 1
+        if total > 1:
+            print(f"\nDone. Items: {total}, Errors: {errors}")
+        return
+
+    if not args.library:
+        print("Specify --library or --item-id")
+        sys.exit(1)
+
+    libraries = client.get_libraries()
+    lib = next((l for l in libraries if l["Name"].lower() == args.library.lower()), None)
+    if not lib:
+        print(f"Library '{args.library}' not found")
+        sys.exit(1)
+
+    items = client.get_all_items(parent_id=lib["Id"])
+    targets = [i for i in items if i.get("Type") in downloadable]
+
+    print(f"\nFound {len(targets)} items in '{lib['Name']}'")
+    skipped = 0
+    errors = 0
+
+    for idx, item in enumerate(targets, 1):
+        dest = build_dest_path(item, output)
+        if should_skip_item(item, dest, method, args.force):
+            skipped += 1
+            continue
+
+        prefix = f"[{idx}/{len(targets)}]"
+        print(f"\n{prefix} {item['Name']}")
+        try:
+            do_download(client, item["Id"], item, dest, method, throttle)
+        except Exception as exc:
+            print(f"  ERROR: {exc}")
+            errors += 1
+
+    print(f"\nDone. Downloaded: {len(targets) - skipped - errors}, "
+          f"Skipped: {skipped}, Errors: {errors}")

emby_cli/commands/list.py

@@ -0,0 +1,35 @@
+"""list command."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from emby_cli.client import EmbyClient
+from emby_cli.util import format_size, item_remote_size
+
+def cmd_list(client: EmbyClient, args: argparse.Namespace) -> None:
+    libraries = client.get_libraries()
+
+    if args.library:
+        lib = next((l for l in libraries if l["Name"].lower() == args.library.lower()), None)
+        if not lib:
+            print(f"Library '{args.library}' not found. Available:")
+            for l in libraries:
+                print(f"  - {l['Name']}")
+            sys.exit(1)
+        items = client.get_all_items(parent_id=lib["Id"])
+        print(f"\n{'Name':<60} {'Type':<12} {'Size':>12}")
+        print("-" * 86)
+        for it in items:
+            if it.get("Type") not in ("Movie", "Episode", "Audio", "Video"):
+                continue
+            size = format_size(item_remote_size(it))
+            print(f"{it['Name']:<60} {it['Type']:<12} {size:>12}")
+        print(f"\nTotal downloadable items: {len([i for i in items if i.get('Type') in ('Movie','Episode','Audio','Video')])}")
+    else:
+        print("\nLibraries on server:")
+        for lib in libraries:
+            count = client.get_items(parent_id=lib["Id"], limit=0)
+            print(f"  [{lib['Id'][:8]}] {lib['Name']:<30} ({count.get('TotalRecordCount', '?')} items)")
+        print()

emby_cli/commands/play.py

@@ -0,0 +1,129 @@
+"""play command — stream URL in an external player."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from emby_cli.client import EmbyClient
+from emby_cli.resolve import (
+    classify_resolution,
+    item_video_width,
+    resolve_title_item,
+)
+
+_MAC_PLAYER_BINS = (
+    "/Applications/VLC.app/Contents/MacOS/VLC",
+    "/Applications/IINA.app/Contents/MacOS/IINA",
+    "/Applications/mpv.app/Contents/MacOS/mpv",
+)
+
+
+def find_player(explicit: str | None = None) -> list[str]:
+    """Resolve an external player command argv, or raise RuntimeError."""
+    if explicit:
+        cmd = shlex.split(explicit)
+        if not cmd:
+            raise RuntimeError("Empty --player / EMBY_PLAYER value")
+        binary = cmd[0]
+        if os.path.sep in binary or binary.startswith("."):
+            if not Path(binary).is_file():
+                raise RuntimeError(f"Player not found: {binary}")
+        elif shutil.which(binary) is None:
+            raise RuntimeError(
+                f"Player '{binary}' not found in PATH. "
+                "Pass a full path via --player or EMBY_PLAYER."
+            )
+        return cmd
+
+    for name in ("vlc", "mpv", "iina"):
+        found = shutil.which(name)
+        if found:
+            return [found]
+
+    if sys.platform == "darwin":
+        for path in _MAC_PLAYER_BINS:
+            if Path(path).is_file():
+                return [path]
+
+    raise RuntimeError(
+        "No external player found (tried vlc, mpv, iina). "
+        "Install one or set --player / EMBY_PLAYER to its path, e.g.\n"
+        "  --player /Applications/VLC.app/Contents/MacOS/VLC"
+    )
+
+
+def play_url(player_cmd: list[str], url: str, *, wait: bool = False) -> int:
+    """Launch *player_cmd* with *url*.
+
+    By default detaches so closing the player window (common on macOS) does not
+    leave this process blocked. Pass wait=True to block until the player exits.
+    """
+    if wait:
+        return subprocess.run([*player_cmd, url], check=False).returncode
+
+    subprocess.Popen(
+        [*player_cmd, url],
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    return 0
+
+
+def redact_url(url: str) -> str:
+    return re.sub(r"(api_key=)[^&]+", r"\1***", url, flags=re.I)
+
+def cmd_play(client: EmbyClient, args: argparse.Namespace) -> None:
+    """Resolve DirectStreamUrl and open it in an external player."""
+    item_id = (args.item_id or "").strip() or None
+    query = (args.query or "").strip() or None
+
+    if not item_id and not query:
+        print("Specify --item-id or a search query "
+              "(e.g. 'Movie (2010)' or 'Show S01E01')")
+        sys.exit(1)
+
+    if item_id:
+        try:
+            item = client.get_item_info(item_id)
+        except Exception as exc:
+            print(f"ERROR fetching item {item_id}: {exc}")
+            sys.exit(1)
+    else:
+        pick_best = bool(getattr(args, "pick_best_item", 0))
+        item = resolve_title_item(client, query, pick_best=pick_best)
+        if item is None:
+            sys.exit(1)
+        item_id = item["Id"]
+
+    try:
+        player_cmd = find_player(getattr(args, "player", None))
+    except RuntimeError as exc:
+        print(f"ERROR: {exc}")
+        sys.exit(1)
+
+    res = classify_resolution(item_video_width(item))
+    year = item.get("ProductionYear", "?")
+    print(f"Playing: {item.get('Name')} ({year}) [{item.get('Type')}, {res}]")
+    try:
+        url = client.resolve_direct_stream_url(item_id)
+    except Exception as exc:
+        print(f"ERROR resolving stream URL: {exc}")
+        sys.exit(1)
+
+    print(f"Stream:  {redact_url(url)}")
+    print(f"Player:  {' '.join(player_cmd)}")
+    wait = bool(getattr(args, "wait", False))
+    rc = play_url(player_cmd, url, wait=wait)
+    if not wait:
+        print("Launched (detached). Use --wait to block until the player exits.")
+    if rc != 0:
+        sys.exit(rc)

emby_cli/commands/search.py

@@ -0,0 +1,31 @@
+"""search command."""
+
+from __future__ import annotations
+
+import argparse
+
+from emby_cli.client import EmbyClient
+from emby_cli.util import format_size, item_remote_size
+
+def cmd_search(client: EmbyClient, args: argparse.Namespace) -> None:
+    uid = client.resolve_user_id()
+    params = {
+        "SearchTerm": args.query,
+        "Limit": 25,
+        "Recursive": "true",
+        "Fields": "Path,MediaSources,Size",
+        "IncludeItemTypes": "Movie,Episode,Audio,Video",
+    }
+    resp = client._get(f"/Users/{uid}/Items", params=params)
+    items = resp.json().get("Items", [])
+
+    if not items:
+        print("No results.")
+        return
+
+    print(f"\n{'ID':<34} {'Name':<50} {'Type':<10} {'Size':>12}")
+    print("-" * 108)
+    for it in items:
+        size = format_size(item_remote_size(it))
+        print(f"{it['Id']:<34} {it['Name']:<50} {it['Type']:<10} {size:>12}")
+    print()

emby_cli/commands/sync.py

@@ -0,0 +1,54 @@
+"""sync command."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from emby_cli.client import EmbyClient
+from emby_cli.download_ops import do_download, should_skip_item
+from emby_cli.util import build_dest_path
+
+def cmd_sync(client: EmbyClient, args: argparse.Namespace) -> None:
+    """Download all media from all libraries (or a specific one)."""
+    output = Path(args.output)
+    downloadable = ("Movie", "Episode", "Audio", "Video")
+    throttle = getattr(args, "throttle", False)
+    method = getattr(args, "method", "download")
+    libraries = client.get_libraries()
+
+    if args.library:
+        libraries = [l for l in libraries if l["Name"].lower() == args.library.lower()]
+        if not libraries:
+            print(f"Library '{args.library}' not found")
+            sys.exit(1)
+
+    total_dl, total_skip, total_err = 0, 0, 0
+
+    for lib in libraries:
+        print(f"\n{'='*60}")
+        print(f"Library: {lib['Name']}")
+        print(f"{'='*60}")
+
+        items = client.get_all_items(parent_id=lib["Id"])
+        targets = [i for i in items if i.get("Type") in downloadable]
+        print(f"Found {len(targets)} items")
+
+        for idx, item in enumerate(targets, 1):
+            dest = build_dest_path(item, output)
+            if should_skip_item(item, dest, method, args.force):
+                total_skip += 1
+                continue
+
+            prefix = f"[{idx}/{len(targets)}]"
+            print(f"\n{prefix} {item['Name']}")
+            try:
+                do_download(client, item["Id"], item, dest, method, throttle)
+                total_dl += 1
+            except Exception as exc:
+                print(f"  ERROR: {exc}")
+                total_err += 1
+
+    print(f"\n{'='*60}")
+    print(f"Sync complete. Downloaded: {total_dl}, Skipped: {total_skip}, Errors: {total_err}")

emby_cli/constants.py

@@ -0,0 +1,9 @@
+"""Shared constants for emby-cli."""
+
+DEFAULT_CHUNK = 8 * 1024 * 1024  # 8 MiB per read
+TICKS_PER_SECOND = 10_000_000  # Emby RunTimeTicks resolution
+MAX_RETRIES = 5
+RETRY_BACKOFF_BASE = 30  # seconds; doubles each retry: 30, 60, 120, 240, 480
+CLIENT_NAME = "emby-cli"
+DEVICE_NAME = "emby-cli"
+DEFAULT_OUTPUT = "./downloads"

emby_cli/download_ops.py

@@ -0,0 +1,47 @@
+"""Shared download dispatch and skip/throttle helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from emby_cli.client import EmbyClient
+from emby_cli.util import (
+    format_duration,
+    format_size,
+    item_duration_seconds,
+    item_playback_rate,
+    should_skip,
+    should_skip_hls,
+)
+
+def resolve_rate(item: dict, throttle: float) -> float | None:
+    if not throttle:
+        return None
+    rate = item_playback_rate(item)
+    if rate:
+        rate *= throttle
+        duration = item_duration_seconds(item)
+        effective = format_duration(duration / throttle if duration else None)
+        print(f"  Throttle: {format_size(rate)}/s x{throttle:.2g} (ETA: {effective})")
+    return rate
+
+
+def do_download(client: EmbyClient, item_id: str, item: dict, dest: Path,
+                  method: str, throttle: float) -> None:
+    """Dispatch a single item download to the right method."""
+    if method == "hls":
+        client.download_item_hls(item_id, dest, throttle=throttle)
+        return
+    rate = resolve_rate(item, throttle)
+    if method == "stream":
+        client.download_item_stream(item_id, dest, rate_bps=rate)
+    else:
+        client.download_item(item_id, dest, rate_bps=rate)
+
+
+def should_skip_item(item: dict, dest: Path, method: str, force: bool) -> bool:
+    if force:
+        return False
+    if method == "hls":
+        return should_skip_hls(dest)
+    return should_skip(item, dest)