emby-cli 0.7.0__tar.gz → 0.7.2__tar.gz

{emby_cli-0.7.0 → emby_cli-0.7.2}/AGENTS.md

@@ -248,7 +248,7 @@ on `client.items`; add `api/people.py` only if person lookup/creation needs
 - **Username/password**: single store `{EMBY_CACHE_DIR}/auth.json` with `contexts[]` + `current_context` (kubeconfig-style). **Password is never stored.** Legacy `*.cache` files migrate automatically.
 - `login` — authenticate, upsert context, activate it.
 - `logout` — `POST /Sessions/Logout` when possible, then remove context.
-- `config` — `current-server`, `get-servers`, `use-server`, `view` (tokens redacted).
+- `config` — `current-server`, `get-servers`, `use-server`, `rename-server`, `view` (tokens redacted). Each context may have an optional `alias` (friendly name); `current_context` still stores the canonical `user@url` name.
 - Other commands: no `--server` → active context; cache hit → reuse token; miss + credentials → transparent login; **HTTP 401** with password available → invalidate cache and re-authenticate **once per top-level request** (no infinite reauth loop).
 - If 401 cannot be recovered (no password, or re-login rejected): raise `AuthenticationError`, clear the stale cache entry, and let `main` print a short stderr message (no traceback).
 - Invalid selectors for `item` / `library` / `collection` are rejected **before** opening a client.
@@ -352,8 +352,10 @@ Read-only entity commands (`item list`, `item search`, `item show`, `item play`)
   Supports `--player`, `--wait`, `--pick-best-item`, `--no-cache`, `--no-parse-query`,
   and comma-separated `--id`. Parent `--id` may appear before the subcommand.
   QUERY defaults to title-line resolution (`resolve_title_items`).
-- `item download` resolves one item by QUERY or `--id` (CSV supported) and downloads
-  via `item_ops` (`download_items`, `download_item_ids`, `download_from_file`).
+- `item download` resolves one item by QUERY or `--id` (CSV supported). A
+  `--id` that refers to a `Series` downloads all episodes in season/episode
+  order. Downloads via `item_ops` (`download_items`, `download_item_ids`,
+  `download_from_file`).
   Supports `--output`, `--method`, `--force`, `--throttle`, `--pick-best-item`,
   `--dry-run`, `--from-file`, `--no-parse-query`, and optional `--mirror-path`.
   QUERY / `--from-file` default to title-line resolution (`resolve_title_items`).

{emby_cli-0.7.0 → emby_cli-0.7.2}/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 0.7.2
+
+### Added
+
+- `item download --id` expands a `Series` ID into all episodes (sorted by
+  season/episode, then Id) and downloads them sequentially. Duplicate
+  SxxExx versions follow the same rules as title-line downloads
+  (`--pick-best-item` or fail with a disambiguation table).
+
+## 0.7.1
+
+### Added
+
+- `config rename-server NAME --new-name ALIAS` to assign a friendly alias to a
+  saved server. Aliases appear in `config get-servers` and work with
+  `config use-server` and `config current-server`.
+
 ## 0.7.0
 
 ### Added

{emby_cli-0.7.0 → emby_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: emby-cli
-Version: 0.7.0
+Version: 0.7.2
 Summary: CLI to list, search, play, and download/backup original media from an Emby server via its REST API.
 Project-URL: Homepage, https://github.com/soukron/emby-cli
 Project-URL: Repository, https://github.com/soukron/emby-cli
@@ -120,6 +120,7 @@ Preview a large operation first, then choose a destination:
 ```bash
 emby-cli item download "breaking bad S01E01" --dry-run
 emby-cli item download --id 123456 --output ./downloads
+emby-cli item download --id 123456 --pick-best-item   # series: one file per SxxExx
 emby-cli item download --from-file titles.txt --dry-run
 emby-cli library download "peliculas 4k" --output ./downloads
 ```
@@ -207,6 +208,8 @@ or environment variables.
 emby-cli config get-servers
 emby-cli config current-server
 emby-cli config use-server 'you@http://emby:8096'
+emby-cli config rename-server 'you@http://emby:8096' --new-name synology
+emby-cli config use-server synology   # alias from rename-server
 emby-cli config view          # tokens are redacted
 emby-cli logout               # revoke and forget the current session
 ```

{emby_cli-0.7.0 → emby_cli-0.7.2}/README.md

@@ -85,6 +85,7 @@ Preview a large operation first, then choose a destination:
 ```bash
 emby-cli item download "breaking bad S01E01" --dry-run
 emby-cli item download --id 123456 --output ./downloads
+emby-cli item download --id 123456 --pick-best-item   # series: one file per SxxExx
 emby-cli item download --from-file titles.txt --dry-run
 emby-cli library download "peliculas 4k" --output ./downloads
 ```
@@ -172,6 +173,8 @@ or environment variables.
 emby-cli config get-servers
 emby-cli config current-server
 emby-cli config use-server 'you@http://emby:8096'
+emby-cli config rename-server 'you@http://emby:8096' --new-name synology
+emby-cli config use-server synology   # alias from rename-server
 emby-cli config view          # tokens are redacted
 emby-cli logout               # revoke and forget the current session
 ```

{emby_cli-0.7.0 → emby_cli-0.7.2}/src/emby_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.0'
-__version_tuple__ = version_tuple = (0, 7, 0)
+__version__ = version = '0.7.2'
+__version_tuple__ = version_tuple = (0, 7, 2)
 
 __commit_id__ = commit_id = None

{emby_cli-0.7.0 → emby_cli-0.7.2}/src/emby_cli/auth_cache.py

@@ -17,11 +17,13 @@ class AuthCacheEntry:
     user_id: str
     saved_at: str
     name: str = ""
+    alias: str = ""
 
     def __post_init__(self) -> None:
         self.server_url = self.server_url.rstrip("/")
         if not self.name:
             self.name = context_name(self.server_url, self.username)
+        self.alias = self.alias.strip()
 
     @classmethod
     def create(
@@ -51,6 +53,32 @@ def context_name(server_url: str, username: str) -> str:
     return f"{username}@{server_url.rstrip('/')}"
 
 
+def display_name(entry: AuthCacheEntry) -> str:
+    """Return the user-facing server label (alias if set, else canonical name)."""
+    return entry.alias or entry.name
+
+
+def validate_alias(alias: str, *, exclude_name: str | None = None) -> str | None:
+    """Return an error message if *alias* is invalid; else ``None``."""
+    text = alias.strip()
+    if not text:
+        return "alias must not be empty"
+    if any(ch.isspace() for ch in text):
+        return "alias must not contain whitespace"
+    if "@" in text:
+        return "alias must not contain '@'"
+    store = load_store()
+    needle = text.casefold()
+    for entry in store.contexts:
+        if exclude_name and entry.name == exclude_name:
+            continue
+        if entry.alias and entry.alias.casefold() == needle:
+            return f"alias '{text}' is already used"
+        if entry.name.casefold() == needle:
+            return f"alias '{text}' conflicts with server name '{entry.name}'"
+    return None
+
+
 def cache_dir() -> Path:
     return Path(os.environ.get("EMBY_CACHE_DIR", Path.home() / ".cache" / "emby-cli"))
 
@@ -72,6 +100,7 @@ def _entry_from_dict(data: dict) -> AuthCacheEntry | None:
             user_id=str(data["user_id"]),
             saved_at=str(data.get("saved_at") or ""),
             name=str(data.get("name") or ""),
+            alias=str(data.get("alias") or ""),
         )
     except (KeyError, TypeError, ValueError):
         return None
@@ -188,13 +217,17 @@ def upsert_context(entry: AuthCacheEntry, *, activate: bool = True) -> None:
     if _auth_cache_disabled():
         return
     store = load_store()
+    canonical = context_name(entry.server_url, entry.username)
+    existing = next((c for c in store.contexts if c.name == canonical), None)
+    preserved_alias = existing.alias if existing else entry.alias
     entry = AuthCacheEntry(
         server_url=entry.server_url,
         username=entry.username,
         access_token=entry.access_token,
         user_id=entry.user_id,
         saved_at=entry.saved_at or datetime.now(timezone.utc).isoformat(),
-        name=entry.name or context_name(entry.server_url, entry.username),
+        name=canonical,
+        alias=preserved_alias,
     )
     store.contexts = [c for c in store.contexts if c.name != entry.name]
     store.contexts.append(entry)
@@ -232,16 +265,25 @@ def remove_context(
     return True
 
 
-def set_current_context(name: str) -> AuthCacheEntry:
-    """Set ``current_context`` by exact name or unique server URL match."""
+def resolve_context(name: str) -> AuthCacheEntry:
+    """Resolve a server selector to exactly one cached context."""
     store = load_store()
     needle = name.strip()
+    if not needle:
+        raise KeyError("context '' not found")
+
     matches = [c for c in store.contexts if c.name == needle]
     if not matches:
-        # Unique match by server_url or username@server fragment.
+        folded = needle.casefold()
+        matches = [
+            c for c in store.contexts
+            if c.alias and c.alias.casefold() == folded
+        ]
+    if not matches:
         by_server = [
             c for c in store.contexts
-            if c.server_url == needle.rstrip("/") or c.name.endswith(f"@{needle.rstrip('/')}")
+            if c.server_url == needle.rstrip("/")
+            or c.name.endswith(f"@{needle.rstrip('/')}")
         ]
         if len(by_server) == 1:
             matches = by_server
@@ -254,12 +296,36 @@ def set_current_context(name: str) -> AuthCacheEntry:
                 matches = by_user_server
     if len(matches) != 1:
         raise KeyError(f"context '{name}' not found")
-    entry = matches[0]
+    return matches[0]
+
+
+def set_current_context(name: str) -> AuthCacheEntry:
+    """Set ``current_context`` by alias, canonical name, or unique server URL."""
+    store = load_store()
+    entry = resolve_context(name)
     store.current_context = entry.name
     save_store(store)
     return entry
 
 
+def rename_context_alias(name: str, alias: str) -> AuthCacheEntry:
+    """Assign a friendly *alias* to the context selected by *name*."""
+    if _auth_cache_disabled():
+        raise RuntimeError("auth cache is disabled")
+    store = load_store()
+    entry = resolve_context(name)
+    err = validate_alias(alias, exclude_name=entry.name)
+    if err:
+        raise ValueError(err)
+    for ctx in store.contexts:
+        if ctx.name == entry.name:
+            ctx.alias = alias.strip()
+            entry = ctx
+            break
+    save_store(store)
+    return entry
+
+
 def load_auth_cache(
     *,
     server_url: str,

{emby_cli-0.7.0 → emby_cli-0.7.2}/src/emby_cli/cli.py

@@ -160,10 +160,24 @@ def build_parser() -> argparse.ArgumentParser:
         help="Set the current server in the credentials file",
     )
     use_srv.add_argument(
+        "server_name",
+        metavar="NAME",
+        help="Server alias, entry name (user@url), or unique server URL",
+    )
+    rename_srv = cfg_sub.add_parser(
+        "rename-server",
+        help="Set a friendly alias for a saved server",
+    )
+    rename_srv.add_argument(
         "server_name",
         metavar="NAME",
         help="Server entry name (user@url) or unique server URL",
     )
+    rename_srv.add_argument(
+        "--new-name",
+        required=True,
+        help="Short alias used by get-servers and use-server",
+    )
     cfg_sub.add_parser(
         "view",
         help="Display credentials file (tokens redacted)",
@@ -526,7 +540,10 @@ def build_parser() -> argparse.ArgumentParser:
 
     it_download = it_sub.add_parser("download", help="Download media items")
     it_download.add_argument("query", nargs="?", metavar="QUERY")
-    it_download.add_argument("--id", help="Media item ID to download (comma-separated for multiple)")
+    it_download.add_argument(
+        "--id",
+        help="Media item ID (comma-separated). Series IDs download all episodes",
+    )
     it_download.add_argument(
         "--type",
         dest="item_type",

{emby_cli-0.7.0 → emby_cli-0.7.2}/src/emby_cli/commands/config.py

@@ -8,9 +8,11 @@ import sys
 
 from emby_cli.auth_cache import (
     auth_store_path,
+    display_name,
     get_active_entry,
     list_contexts,
     load_store,
+    rename_context_alias,
     set_current_context,
 )
 
@@ -20,7 +22,7 @@ def cmd_config_current_server(_args: argparse.Namespace) -> None:
     if active is None:
         print("error: no current server", file=sys.stderr)
         sys.exit(1)
-    print(active.name)
+    print(display_name(active))
 
 
 def cmd_config_get_servers(_args: argparse.Namespace) -> None:
@@ -33,7 +35,7 @@ def cmd_config_get_servers(_args: argparse.Namespace) -> None:
     rows = []
     for ctx in contexts:
         current = "*" if ctx.name == store.current_context else ""
-        rows.append((current, ctx.name, ctx.server_url, ctx.username))
+        rows.append((current, display_name(ctx), ctx.server_url, ctx.username))
 
     headers = ("CURRENT", "NAME", "SERVER", "USER")
     widths = [len(h) for h in headers]
@@ -59,7 +61,31 @@ def cmd_config_use_server(args: argparse.Namespace) -> None:
     except KeyError as exc:
         print(f"error: {exc}", file=sys.stderr)
         sys.exit(1)
-    print(f"Switched to server {entry.name}")
+    label = display_name(entry)
+    if label == entry.name:
+        print(f"Switched to server {entry.name}")
+    else:
+        print(f'Switched to server "{label}" ({entry.name})')
+
+
+def cmd_config_rename_server(args: argparse.Namespace) -> None:
+    selector = (getattr(args, "server_name", None) or "").strip()
+    alias = (getattr(args, "new_name", None) or "").strip()
+    if not selector:
+        print("error: provide a server name", file=sys.stderr)
+        sys.exit(1)
+    if not alias:
+        print("error: provide --new-name", file=sys.stderr)
+        sys.exit(1)
+    try:
+        entry = rename_context_alias(selector, alias)
+    except KeyError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except ValueError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    print(f'Renamed server "{entry.name}" to "{display_name(entry)}"')
 
 
 def cmd_config_view(_args: argparse.Namespace) -> None:
@@ -70,6 +96,7 @@ def cmd_config_view(_args: argparse.Namespace) -> None:
         "contexts": [
             {
                 "name": c.name,
+                "alias": c.alias or None,
                 "server_url": c.server_url,
                 "username": c.username,
                 "access_token": "***",
@@ -89,13 +116,14 @@ def cmd_config(args: argparse.Namespace) -> None:
         "current-server": cmd_config_current_server,
         "get-servers": cmd_config_get_servers,
         "use-server": cmd_config_use_server,
+        "rename-server": cmd_config_rename_server,
         "view": cmd_config_view,
     }
     handler = handlers.get(sub) if sub else None
     if handler is None:
         print(
             "error: provide a config subcommand "
-            "(current-server, get-servers, use-server, view)",
+            "(current-server, get-servers, use-server, rename-server, view)",
             file=sys.stderr,
         )
         sys.exit(1)

{emby_cli-0.7.0 → emby_cli-0.7.2}/src/emby_cli/commands/item.py

@@ -248,6 +248,7 @@ def _cmd_download(client: EmbyClient, args: argparse.Namespace) -> None:
             raw_type=_text(args, "item_type"),
             mirror_path=opts.mirror_path,
             path_strip=opts.path_strip,
+            pick_best=pick_best,
         )
         print_done(stats)
         raise SystemExit(stats.exit_code())

{emby_cli-0.7.0 → emby_cli-0.7.2}/src/emby_cli/item_ops.py

@@ -18,9 +18,10 @@ import requests
 
 from emby_cli.client import EmbyClient
 from emby_cli.constants import SEARCH_ITEM_TYPES, SHOW_ITEM_FIELDS
-from emby_cli.media_sort import sort_media_items
+from emby_cli.media_sort import sort_key_id, sort_media_items
 from emby_cli.output import Stats, print_done, print_download, print_error, print_skip
 from emby_cli.resolve import (
+    _pick_episode_versions,
     classify_resolution,
     item_label,
     item_video_width,
@@ -454,6 +455,59 @@ class DownloadOpts:
         )
 
 
+def sort_episodes(episodes: list[dict]) -> list[dict]:
+    """Sort episodes by season, episode number, then Emby Id."""
+
+    def key(ep: dict) -> tuple:
+        season = ep.get("ParentIndexNumber")
+        number = ep.get("IndexNumber")
+        if season is not None and number is not None:
+            return (0, int(season), int(number), sort_key_id(ep))
+        if season is not None:
+            return (1, int(season), 0, sort_key_id(ep))
+        if number is not None:
+            return (2, 0, int(number), sort_key_id(ep))
+        return (3, 0, 0, sort_key_id(ep))
+
+    return sorted(episodes, key=key)
+
+
+def expand_item_for_download(
+    client: EmbyClient,
+    item: dict,
+    *,
+    pick_best: bool = False,
+) -> list[dict] | None:
+    """Return download targets for *item* (one row, or all episodes for Series)."""
+    if item.get("Type") != "Series":
+        return [item]
+
+    name = item.get("Name") or item.get("Id")
+    try:
+        episodes = client.get_show_episodes(item["Id"], season=None)
+    except (requests.RequestException, RuntimeError) as exc:
+        print_error(f"listing episodes for series '{name}': {exc}")
+        return None
+
+    if not episodes:
+        print(f"Series '{name}': no episodes found.")
+        return []
+
+    series_name = item.get("Name")
+    enriched: list[dict] = []
+    for ep in episodes:
+        row = dict(ep)
+        if series_name and not row.get("SeriesName"):
+            row["SeriesName"] = series_name
+        enriched.append(row)
+
+    picked = _pick_episode_versions(sort_episodes(enriched), pick_best=pick_best)
+    if picked is None:
+        return None
+    print(f"Series '{name}': {len(picked)} episode(s)")
+    return picked
+
+
 def resolve_rate(item: dict, throttle: float) -> float | None:
     if not throttle:
         return None
@@ -584,6 +638,7 @@ def download_item_ids(
     raw_type: str | None = None,
     mirror_path: bool = False,
     path_strip: str | None = None,
+    pick_best: bool = False,
 ) -> Stats:
     """Download comma-separated item IDs."""
     item_ids = [part.strip() for part in item_id.split(",") if part.strip()]
@@ -605,7 +660,14 @@ def download_item_ids(
             )
             stats.error += 1
             continue
-        items.append(item)
+        targets = expand_item_for_download(client, item, pick_best=pick_best)
+        if targets is None:
+            stats.error += 1
+            continue
+        if not targets and item.get("Type") == "Series":
+            stats.error += 1
+            continue
+        items.extend(targets)
     if items:
         got = download_items(
             client,
@@ -673,9 +735,21 @@ def download_from_file(
                 totals.error += 1
                 continue
 
-            result = download_one_item(
+            targets = expand_item_for_download(client, item, pick_best=pick_best)
+            if targets is None:
+                elapsed = time.monotonic() - line_t0
+                line_stats.append((label, "ERROR", elapsed, "ambiguous episode versions"))
+                totals.error += 1
+                continue
+            if not targets:
+                elapsed = time.monotonic() - line_t0
+                line_stats.append((label, "ERROR", elapsed, "no episodes"))
+                totals.error += 1
+                continue
+
+            got = download_items(
                 client,
-                item,
+                targets,
                 output,
                 method=method,
                 force=force,
@@ -685,20 +759,20 @@ def download_from_file(
                 path_strip=path_strip,
             )
             elapsed = time.monotonic() - line_t0
-            status_map = {
-                "ok": "OK",
-                "skip": "SKIPPED",
-                "error": "ERROR",
-                "dry_run": "DRY RUN",
-            }
-            status = status_map.get(result, "ERROR")
+            if got.error:
+                status = "ERROR"
+            elif dry_run and got.ok:
+                status = "DRY RUN"
+            elif got.skip and not got.ok:
+                status = "SKIPPED"
+            elif got.skip:
+                status = "PARTIAL"
+            else:
+                status = "OK"
             line_stats.append((label, status, elapsed, item.get("Name", "")))
-            if result == "ok":
-                totals.ok += 1
-            elif result == "skip":
-                totals.skip += 1
-            elif result == "error":
-                totals.error += 1
+            totals.ok += got.ok
+            totals.skip += got.skip
+            totals.error += got.error
             continue
 
         label = raw_line

{emby_cli-0.7.0 → emby_cli-0.7.2}/tests/test_auth_cache.py

@@ -9,15 +9,18 @@ from emby_cli.auth_cache import (
     AuthCacheEntry,
     auth_store_path,
     clear_auth_cache,
+    display_name,
     get_active_entry,
     list_auth_cache_entries,
     list_contexts,
     load_auth_cache,
     load_store,
+    rename_context_alias,
     save_auth_cache,
     set_current_context,
     unique_cached_server_urls,
     upsert_context,
+    validate_alias,
 )
 
 
@@ -79,6 +82,46 @@ def test_set_current_context_by_unique_server(tmp_path, monkeypatch):
     assert get_active_entry().username == "alice"
 
 
+def test_rename_context_alias_and_use_by_alias(tmp_path, monkeypatch):
+    monkeypatch.setenv("EMBY_CACHE_DIR", str(tmp_path))
+    save_auth_cache(
+        AuthCacheEntry.create("http://a:8096", "alice", "tok-a", "uid-a")
+    )
+    save_auth_cache(
+        AuthCacheEntry.create("http://b:8096", "bob", "tok-b", "uid-b")
+    )
+    entry = rename_context_alias("alice@http://a:8096", "home")
+    assert display_name(entry) == "home"
+    assert entry.name == "alice@http://a:8096"
+
+    set_current_context("home")
+    assert get_active_entry().name == "alice@http://a:8096"
+
+    store = load_store()
+    assert store.contexts[0].alias == "home" or store.contexts[1].alias == "home"
+
+
+def test_upsert_preserves_alias(tmp_path, monkeypatch):
+    monkeypatch.setenv("EMBY_CACHE_DIR", str(tmp_path))
+    save_auth_cache(
+        AuthCacheEntry.create("http://a:8096", "alice", "tok-a", "uid-a")
+    )
+    rename_context_alias("alice@http://a:8096", "home")
+    upsert_context(
+        AuthCacheEntry.create("http://a:8096", "alice", "tok-new", "uid-a"),
+        activate=True,
+    )
+    ctx = next(c for c in list_contexts() if c.username == "alice")
+    assert ctx.alias == "home"
+    assert ctx.access_token == "tok-new"
+
+
+def test_validate_alias_rejects_whitespace_and_at(tmp_path, monkeypatch):
+    monkeypatch.setenv("EMBY_CACHE_DIR", str(tmp_path))
+    assert "whitespace" in validate_alias("my home")
+    assert "@" in validate_alias("user@host")
+
+
 def test_load_prefers_active_for_server(tmp_path, monkeypatch):
     monkeypatch.setenv("EMBY_CACHE_DIR", str(tmp_path))
     older = AuthCacheEntry.create("http://host:8096", "alice", "tok-a", "uid-a")

{emby_cli-0.7.0 → emby_cli-0.7.2}/tests/test_config.py

@@ -10,6 +10,7 @@ from emby_cli.auth_cache import AuthCacheEntry, save_auth_cache, upsert_context
 from emby_cli.commands.config import (
     cmd_config_current_server,
     cmd_config_get_servers,
+    cmd_config_rename_server,
     cmd_config_use_server,
     cmd_config_view,
 )
@@ -61,6 +62,75 @@ def test_config_use_server(tmp_path, monkeypatch, capsys):
     assert capsys.readouterr().out.strip() == "alice@http://a:8096"
 
 
+def test_config_rename_and_use_alias(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("EMBY_CACHE_DIR", str(tmp_path))
+    save_auth_cache(
+        AuthCacheEntry.create(
+            "http://emby.villageek.gmbros.net",
+            "media",
+            "tok-a",
+            "uid-a",
+        )
+    )
+    save_auth_cache(
+        AuthCacheEntry.create(
+            "http://sniperembyp7p8.zapto.org:8096",
+            "Rbembypr022",
+            "tok-b",
+            "uid-b",
+        )
+    )
+    cmd_config_rename_server(
+        argparse.Namespace(
+            server_name="media@http://emby.villageek.gmbros.net",
+            new_name="synology",
+        )
+    )
+    assert (
+        'Renamed server "media@http://emby.villageek.gmbros.net" to "synology"'
+        in capsys.readouterr().out
+    )
+
+    cmd_config_get_servers(argparse.Namespace())
+    out = capsys.readouterr().out
+    assert "synology" in out
+    assert "media@http://emby.villageek.gmbros.net" not in out.split("SERVER")[0]
+
+    cmd_config_use_server(argparse.Namespace(server_name="synology"))
+    assert (
+        'Switched to server "synology" (media@http://emby.villageek.gmbros.net)'
+        in capsys.readouterr().out
+    )
+    cmd_config_current_server(argparse.Namespace())
+    assert capsys.readouterr().out.strip() == "synology"
+
+
+def test_config_rename_server_duplicate_alias(tmp_path, monkeypatch, capsys):
+    monkeypatch.setenv("EMBY_CACHE_DIR", str(tmp_path))
+    save_auth_cache(
+        AuthCacheEntry.create("http://a:8096", "alice", "tok-a", "uid-a")
+    )
+    save_auth_cache(
+        AuthCacheEntry.create("http://b:8096", "bob", "tok-b", "uid-b")
+    )
+    cmd_config_rename_server(
+        argparse.Namespace(
+            server_name="alice@http://a:8096",
+            new_name="home",
+        )
+    )
+    capsys.readouterr()
+    with pytest.raises(SystemExit) as exc:
+        cmd_config_rename_server(
+            argparse.Namespace(
+                server_name="bob@http://b:8096",
+                new_name="home",
+            )
+        )
+    assert exc.value.code == 1
+    assert "already used" in capsys.readouterr().err
+
+
 def test_config_view_redacts_token(tmp_path, monkeypatch, capsys):
     monkeypatch.setenv("EMBY_CACHE_DIR", str(tmp_path))
     save_auth_cache(

{emby_cli-0.7.0 → emby_cli-0.7.2}/tests/test_item_ops.py

@@ -14,8 +14,10 @@ from emby_cli.item_ops import (
     ItemListingQuery,
     ItemResolutionError,
     build_item_listing_query,
+    download_item_ids,
     emby_search_term_for_strict_query,
     episodes_for_title_line,
+    expand_item_for_download,
     fetch_item_listing,
     item_types_for_api,
     matches_strict_name_query,
@@ -24,8 +26,10 @@ from emby_cli.item_ops import (
     play_url,
     playable_items_for_parent,
     resolve_item,
+    sort_episodes,
     split_listing_search_query,
 )
+from emby_cli.output import Stats
 
 ITEMS = [
     {"Id": "100", "Name": "The Matrix", "Type": "Movie", "ProductionYear": 1999},
@@ -339,3 +343,60 @@ def test_resolve_item_by_id_prefix_uses_catalog():
         assert resolve_item(client, item_id="20", use_cache=False) == ITEMS[1]
     get.assert_called_once_with("20", fields=SHOW_ITEM_FIELDS, use_cache=False)
     search.assert_called_once_with("", item_types="Movie,Episode,Audio,Video", use_cache=False)
+
+
+def test_sort_episodes_orders_by_season_and_number():
+    episodes = [
+        {"Id": "3", "ParentIndexNumber": 2, "IndexNumber": 1},
+        {"Id": "1", "ParentIndexNumber": 1, "IndexNumber": 2},
+        {"Id": "2", "ParentIndexNumber": 1, "IndexNumber": 1},
+    ]
+    ordered = sort_episodes(episodes)
+    assert [ep["Id"] for ep in ordered] == ["2", "1", "3"]
+
+
+def test_expand_item_for_download_series(capsys):
+    client = MagicMock()
+    series = {"Id": "s1", "Name": "Show", "Type": "Series"}
+    client.get_show_episodes.return_value = [
+        {"Id": "e2", "Type": "Episode", "ParentIndexNumber": 1, "IndexNumber": 2, "Name": "B"},
+        {"Id": "e1", "Type": "Episode", "ParentIndexNumber": 1, "IndexNumber": 1, "Name": "A"},
+    ]
+    targets = expand_item_for_download(client, series)
+    assert targets is not None
+    assert [ep["Id"] for ep in targets] == ["e1", "e2"]
+    assert targets[0]["SeriesName"] == "Show"
+    assert "2 episode(s)" in capsys.readouterr().out
+    client.get_show_episodes.assert_called_once_with("s1", season=None)
+
+
+def test_expand_item_for_download_movie_passthrough():
+    client = MagicMock()
+    movie = {"Id": "m1", "Name": "Film", "Type": "Movie"}
+    assert expand_item_for_download(client, movie) == [movie]
+    client.get_show_episodes.assert_not_called()
+
+
+def test_download_item_ids_expands_series(tmp_path, capsys):
+    client = MagicMock()
+    series = {"Id": "s1", "Name": "Show", "Type": "Series"}
+    episodes = [
+        {"Id": "e1", "Type": "Episode", "ParentIndexNumber": 1, "IndexNumber": 1, "Name": "A"},
+    ]
+    client.get_item_info.return_value = series
+    client.get_show_episodes.return_value = episodes
+    with patch("emby_cli.item_ops.download_items") as download_items:
+        download_items.return_value = Stats(ok=1)
+        stats = download_item_ids(
+            client,
+            "s1",
+            tmp_path,
+            method="download",
+            force=False,
+            throttle=0,
+            dry_run=True,
+        )
+    assert stats.ok == 1
+    passed_items = download_items.call_args.args[1]
+    assert len(passed_items) == 1
+    assert passed_items[0]["Id"] == "e1"