emby-cli 0.2.0__tar.gz → 0.2.2__tar.gz

emby_cli-0.2.2/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## Unreleased
+
+## 0.2.2
+
+- `version`: show emby-cli version; with valid server credentials also show Emby `/System/Info` version.
+- `info`: session summary (user, url, server, version, os, id) plus library names and item counts from `GET /Items/Counts` (replaces draft `whoami`).
+- `--pick-best-item` is a flag (presence enables auto-select); no longer takes `0`/`1`.
+- `info` / `version` probe the server once (no retries); on failure show configured user/URL and mark server name/version as not validated.
+- Note: `/Items/Counts` may count multiple versions of the same title higher than UI “items” views.
+- `probe_session`: fall back to `/System/Info/Public` when full `/System/Info` is forbidden (non-admin users); still proceed with Views/Counts.
+- Avoid broken `/Users/Me` on some Emby servers (HTTP 500 Guid format): use `User` from authenticate or `/Users/{id}`.
+- `list`: library table is ID/Name/Type/Items (no Year/Res); gather all counts before printing; `list -l` keeps media table like `search`.
+
+## 0.2.0
+
+- API fixes: `get_item_info` Fields, `/Users/Me`, safer 416 resume, `api_key` on play URLs, client version from package, `/emby` base URL normalize, HLS without invalid `copy` codecs, paginated episodes.
+- Shared resolve for `play`/`batch` (strict by default; `--pick-best-item` flag).
+- Homogeneous CLI messages (`output.py`); shared library/download loops; non-zero exit on errors / batch not-found.
+- `search`: paginate Emby results (was capped at 25); `--count` / `-n` to limit how many to return (default: all).
+- More tests (`test_client`, `test_output`, parser coverage).

{emby_cli-0.2.0 → emby_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emby-cli
-Version: 0.2.0
+Version: 0.2.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
@@ -70,18 +70,22 @@ See `.env.example`. The app does not load `.env` itself — `source` it or expor
 ## Usage
 
 ```bash
+emby-cli version
+emby-cli info
 emby-cli list
 emby-cli search "Title"
 emby-cli search "Title" --count 50
 emby-cli download -i <itemId> -o ./downloads
 emby-cli sync -l "Movies"
 emby-cli batch -F titles.txt -n
-emby-cli batch -F titles.txt --pick-best-item 1
+emby-cli batch -F titles.txt --pick-best-item
 emby-cli play "Movie (2010)"
-emby-cli play "Show S01E01" --pick-best-item 1
+emby-cli play "Show S01E01" --pick-best-item
 ```
 
-Title resolution (`play` / `batch`) is **strict** by default (year mismatch or multiple matches fail that line). Pass `--pick-best-item 1` to auto-select the best ≤1080p version. In `batch`, a season line like `Show S01` downloads the whole season (with the same pick-best rule per episode version).
+`info` reports libraries and totals from `GET /Items/Counts` (totals may include multiple versions of the same title).
+
+Title resolution (`play` / `batch`) is **strict** by default (year mismatch or multiple matches fail that line). Pass `--pick-best-item` to auto-select the best ≤1080p version. In `batch`, a season line like `Show S01` downloads the whole season (with the same pick-best rule per episode version).
 
 Download methods (`-m` / `EMBY_METHOD`):
 

{emby_cli-0.2.0 → emby_cli-0.2.2}/README.md

@@ -36,18 +36,22 @@ See `.env.example`. The app does not load `.env` itself — `source` it or expor
 ## Usage
 
 ```bash
+emby-cli version
+emby-cli info
 emby-cli list
 emby-cli search "Title"
 emby-cli search "Title" --count 50
 emby-cli download -i <itemId> -o ./downloads
 emby-cli sync -l "Movies"
 emby-cli batch -F titles.txt -n
-emby-cli batch -F titles.txt --pick-best-item 1
+emby-cli batch -F titles.txt --pick-best-item
 emby-cli play "Movie (2010)"
-emby-cli play "Show S01E01" --pick-best-item 1
+emby-cli play "Show S01E01" --pick-best-item
 ```
 
-Title resolution (`play` / `batch`) is **strict** by default (year mismatch or multiple matches fail that line). Pass `--pick-best-item 1` to auto-select the best ≤1080p version. In `batch`, a season line like `Show S01` downloads the whole season (with the same pick-best rule per episode version).
+`info` reports libraries and totals from `GET /Items/Counts` (totals may include multiple versions of the same title).
+
+Title resolution (`play` / `batch`) is **strict** by default (year mismatch or multiple matches fail that line). Pass `--pick-best-item` to auto-select the best ≤1080p version. In `batch`, a season line like `Show S01` downloads the whole season (with the same pick-best rule per episode version).
 
 Download methods (`-m` / `EMBY_METHOD`):
 

{emby_cli-0.2.0 → emby_cli-0.2.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.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.2'
+__version_tuple__ = version_tuple = (0, 2, 2)
 
 __commit_id__ = commit_id = None

{emby_cli-0.2.0 → emby_cli-0.2.2}/src/emby_cli/cli.py

@@ -15,10 +15,12 @@ import requests
 from emby_cli.client import EmbyClient
 from emby_cli.commands.batch import cmd_batch
 from emby_cli.commands.download import cmd_download
+from emby_cli.commands.info import cmd_info
 from emby_cli.commands.list import cmd_list
 from emby_cli.commands.play import cmd_play
 from emby_cli.commands.search import cmd_search
 from emby_cli.commands.sync import cmd_sync
+from emby_cli.commands.version import cmd_version
 from emby_cli.constants import DEFAULT_OUTPUT
 
 
@@ -78,9 +80,9 @@ def build_parser() -> argparse.ArgumentParser:
                          "/Applications/VLC.app/Contents/MacOS/VLC")
     pl.add_argument("--wait", action="store_true",
                     help="Block until the player process exits (default: detach and return)")
-    pl.add_argument("--pick-best-item", type=int, choices=[0, 1], default=0,
-                    help="On ambiguous search results: 0=list and fail (default), "
-                         "1=auto-select best ≤1080p")
+    pl.add_argument("--pick-best-item", action="store_true",
+                    help="On ambiguous search results, auto-select best ≤1080p "
+                         "(default: list matches and fail)")
 
     sy = sub.add_parser("sync", help="Sync all libraries (or one with --library)")
     sy.add_argument("--library", "-l", default=env("EMBY_LIBRARY"), help="Specific library to sync (env: EMBY_LIBRARY)")
@@ -106,9 +108,16 @@ def build_parser() -> argparse.ArgumentParser:
                     choices=["download", "stream", "hls"],
                     help="Download method: 'download' (API Download), 'stream' (browser-like original.*), "
                          "or 'hls' (stream chunks + remux) (env: EMBY_METHOD)")
-    ba.add_argument("--pick-best-item", type=int, choices=[0, 1], default=0,
-                    help="On ambiguous search results: 0=fail the line (default), "
-                         "1=auto-select best ≤1080p (also per episode version in a season)")
+    ba.add_argument("--pick-best-item", action="store_true",
+                    help="On ambiguous search results, auto-select best ≤1080p "
+                         "(also per episode version in a season; default: fail the line)")
+
+    sub.add_parser("version", help="Show emby-cli version (and Emby server version if credentials work)")
+    sub.add_parser(
+        "info",
+        help="Show session user, server details, libraries, and item counts "
+             "(via /Items/Counts; versions may inflate totals)",
+    )
 
     return p
 
@@ -117,6 +126,14 @@ def main() -> None:
     parser = build_parser()
     args = parser.parse_args()
 
+    if args.command == "version":
+        cmd_version(args)
+        return
+
+    if args.command == "info":
+        cmd_info(args)
+        return
+
     if not args.server:
         parser.error("Provide --server or set EMBY_SERVER")
 

{emby_cli-0.2.0 → emby_cli-0.2.2}/src/emby_cli/client.py

@@ -16,6 +16,8 @@ from emby_cli.constants import (
     CLIENT_NAME,
     DEFAULT_CHUNK,
     DEVICE_NAME,
+    INFO_RETRIES,
+    INFO_TIMEOUT,
     ITEM_FIELDS,
     MAX_RETRIES,
     RETRY_BACKOFF_BASE,
@@ -71,35 +73,57 @@ class EmbyClient:
             parts.append(f'Token="{self.access_token}"')
         return {"X-Emby-Authorization": ", ".join(parts)}
 
-    def _request_with_retry(self, method: str, path: str, **kwargs) -> requests.Response:
+    def _request_with_retry(
+        self,
+        method: str,
+        path: str,
+        *,
+        retries: int | None = None,
+        **kwargs,
+    ) -> requests.Response:
         kwargs.setdefault("headers", self._auth_header())
         url = self._url(path)
+        max_attempts = MAX_RETRIES if retries is None else max(1, retries)
         resp = None
-        for attempt in range(1, MAX_RETRIES + 1):
+        for attempt in range(1, max_attempts + 1):
             try:
                 resp = self.session.request(method, url, **kwargs)
                 resp.raise_for_status()
                 return resp
             except (requests.ConnectionError, requests.Timeout) as exc:
-                if attempt == MAX_RETRIES:
+                if attempt == max_attempts:
                     raise
                 wait = RETRY_BACKOFF_BASE * (2 ** (attempt - 1))
-                print(f"  Connection error (attempt {attempt}/{MAX_RETRIES}), retrying in {wait}s: {exc}")
+                print(f"  Connection error (attempt {attempt}/{max_attempts}), retrying in {wait}s: {exc}")
                 time.sleep(wait)
             except requests.HTTPError:
-                if resp is not None and resp.status_code >= 500 and attempt < MAX_RETRIES:
+                if resp is not None and resp.status_code >= 500 and attempt < max_attempts:
                     wait = RETRY_BACKOFF_BASE * (2 ** (attempt - 1))
-                    print(f"  Server error {resp.status_code} (attempt {attempt}/{MAX_RETRIES}), retrying in {wait}s")
+                    print(f"  Server error {resp.status_code} (attempt {attempt}/{max_attempts}), retrying in {wait}s")
                     time.sleep(wait)
                 else:
                     raise
         raise RuntimeError("unreachable")
 
-    def _get(self, path: str, params: dict | None = None, **kwargs) -> requests.Response:
-        return self._request_with_retry("GET", path, params=params, **kwargs)
-
-    def _post(self, path: str, payload: dict | None = None) -> requests.Response:
-        return self._request_with_retry("POST", path, json=payload)
+    def _get(
+        self,
+        path: str,
+        params: dict | None = None,
+        *,
+        retries: int | None = None,
+        **kwargs,
+    ) -> requests.Response:
+        return self._request_with_retry("GET", path, params=params, retries=retries, **kwargs)
+
+    def _post(
+        self,
+        path: str,
+        payload: dict | None = None,
+        *,
+        retries: int | None = None,
+        **kwargs,
+    ) -> requests.Response:
+        return self._request_with_retry("POST", path, json=payload, retries=retries, **kwargs)
 
     @staticmethod
     def _ensure_api_key(url: str, token: str | None) -> str:
@@ -119,24 +143,39 @@ class EmbyClient:
 
     # -- auth ----------------------------------------------------------------
 
-    def authenticate(self, username: str, password: str) -> None:
+    def authenticate(
+        self,
+        username: str,
+        password: str,
+        *,
+        timeout: float | None = None,
+        retries: int | None = None,
+    ) -> dict:
+        """Authenticate by name. Returns the Emby ``User`` object from the response."""
         data = {"Username": username, "Pw": password}
-        resp = self._post("/Users/AuthenticateByName", data)
+        kwargs: dict = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        if retries is not None:
+            kwargs["retries"] = retries
+        resp = self._post("/Users/AuthenticateByName", data, **kwargs)
         body = resp.json()
         try:
             self.access_token = body["AccessToken"]
-            self.user_id = body["User"]["Id"]
+            user = body["User"]
+            self.user_id = user["Id"]
         except (KeyError, TypeError) as exc:
             raise RuntimeError(
                 "Authentication response missing AccessToken or User.Id"
             ) from exc
+        return user
 
     def resolve_user_id(self) -> str:
         if self.user_id:
             return self.user_id
         # Prefer current user bound to the token / API key
         try:
-            me = self._get("/Users/Me").json()
+            me = self.get_current_user()
             uid = me.get("Id")
             if uid:
                 self.user_id = uid
@@ -149,11 +188,133 @@ class EmbyClient:
         self.user_id = users[0]["Id"]
         return self.user_id
 
+    # -- system --------------------------------------------------------------
+
+    def get_system_info(
+        self,
+        *,
+        timeout: float | None = None,
+        retries: int | None = None,
+    ) -> dict:
+        """Authenticated server info (``GET /System/Info``).
+
+        Full details often require an admin / API-key context; non-admin
+        users may get HTTP 401/403 — prefer :meth:`get_system_info_public`
+        as a fallback.
+        """
+        kwargs: dict = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        if retries is not None:
+            kwargs["retries"] = retries
+        return self._get("/System/Info", **kwargs).json()
+
+    def get_system_info_public(
+        self,
+        *,
+        timeout: float | None = None,
+        retries: int | None = None,
+    ) -> dict:
+        """Public server info (``GET /System/Info/Public``): name, version, addresses."""
+        kwargs: dict = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        if retries is not None:
+            kwargs["retries"] = retries
+        return self._get("/System/Info/Public", **kwargs).json()
+
+    def get_current_user(
+        self,
+        *,
+        timeout: float | None = None,
+        retries: int | None = None,
+    ) -> dict:
+        """Current user (``GET /Users/Me``, with fallbacks).
+
+        Some Emby builds return HTTP 500 on ``/Users/Me`` ("Guid should
+        contain…dashes"). Fall back to ``/Users/{user_id}`` when known, else
+        the first entry from ``GET /Users``.
+        """
+        kwargs: dict = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        if retries is not None:
+            kwargs["retries"] = retries
+        try:
+            return self._get("/Users/Me", **kwargs).json()
+        except requests.HTTPError:
+            pass
+        uid = self.user_id
+        if not uid:
+            users = self._get("/Users", **kwargs).json()
+            if not users:
+                raise RuntimeError("No users found on server")
+            uid = users[0]["Id"]
+            self.user_id = uid
+        return self._get(f"/Users/{uid}", **kwargs).json()
+
+    def probe_session(
+        self,
+        *,
+        username: str | None = None,
+        password: str = "",
+    ) -> tuple[dict, dict]:
+        """One-shot auth + current user + system info (no retries).
+
+        Uses the ``User`` from ``AuthenticateByName`` when logging in by name
+        (avoids broken ``/Users/Me`` on some servers). Tries ``/System/Info``
+        then ``/System/Info/Public``.
+        """
+        kwargs = {"timeout": INFO_TIMEOUT, "retries": INFO_RETRIES}
+        user: dict | None = None
+        if username is not None:
+            user = self.authenticate(username, password, **kwargs)
+        if user is None:
+            user = self.get_current_user(**kwargs)
+        elif not user.get("Id") and self.user_id:
+            user = self.get_current_user(**kwargs)
+        try:
+            info = self.get_system_info(**kwargs)
+        except requests.HTTPError:
+            try:
+                info = self.get_system_info_public(**kwargs)
+            except requests.HTTPError:
+                info = {}
+        return user, info
+
+    def get_item_counts(
+        self,
+        user_id: str | None = None,
+        *,
+        timeout: float | None = None,
+        retries: int | None = None,
+    ) -> dict:
+        """Aggregate library counts (``GET /Items/Counts``)."""
+        params: dict = {}
+        if user_id:
+            params["UserId"] = user_id
+        kwargs: dict = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        if retries is not None:
+            kwargs["retries"] = retries
+        return self._get("/Items/Counts", params=params or None, **kwargs).json()
+
     # -- browse --------------------------------------------------------------
 
-    def get_libraries(self) -> list[dict]:
+    def get_libraries(
+        self,
+        *,
+        timeout: float | None = None,
+        retries: int | None = None,
+    ) -> list[dict]:
         uid = self.resolve_user_id()
-        resp = self._get(f"/Users/{uid}/Views")
+        kwargs: dict = {}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+        if retries is not None:
+            kwargs["retries"] = retries
+        resp = self._get(f"/Users/{uid}/Views", **kwargs)
         return resp.json().get("Items", [])
 
     def get_items(

{emby_cli-0.2.0 → emby_cli-0.2.2}/src/emby_cli/commands/batch.py

@@ -21,7 +21,7 @@ def cmd_batch(client: EmbyClient, args: argparse.Namespace) -> None:
     throttle = float(getattr(args, "throttle", 0) or 0)
     method = getattr(args, "method", "download")
     dry_run = bool(getattr(args, "dry_run", False))
-    pick_best = bool(getattr(args, "pick_best_item", 0))
+    pick_best = bool(getattr(args, "pick_best_item", False))
 
     if dry_run:
         print("*** DRY RUN — no files will be downloaded ***\n")

emby_cli-0.2.2/src/emby_cli/commands/info.py

@@ -0,0 +1,125 @@
+"""info command — session + server inventory."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from urllib.parse import urlparse
+
+import requests
+
+from emby_cli.client import EmbyClient
+from emby_cli.constants import INFO_RETRIES, INFO_TIMEOUT
+
+# Always shown (even when 0).
+_PRIMARY_COUNTS = (
+    ("movies", "MovieCount"),
+    ("series", "SeriesCount"),
+    ("episodes", "EpisodeCount"),
+    ("songs", "SongCount"),
+    ("albums", "AlbumCount"),
+)
+
+# Shown only when > 0.
+_EXTRA_COUNTS = (
+    ("boxsets", "BoxSetCount"),
+    ("books", "BookCount"),
+    ("trailers", "TrailerCount"),
+    ("musicvideos", "MusicVideoCount"),
+    ("artists", "ArtistCount"),
+)
+
+
+def _norm_host(url: str) -> str:
+    p = urlparse(url if "://" in url else f"http://{url}")
+    host = (p.hostname or "").lower()
+    port = p.port
+    if port and port not in (80, 443, 8096):
+        return f"{host}:{port}"
+    return host
+
+
+def _addr_differs(configured: str, candidate: str | None) -> bool:
+    if not candidate:
+        return False
+    return _norm_host(configured) != _norm_host(candidate)
+
+
+def cmd_info(args: argparse.Namespace) -> None:
+    if not args.server:
+        print("error: provide --server or set EMBY_SERVER", file=sys.stderr)
+        sys.exit(1)
+    if not args.api_key and not args.username:
+        print(
+            "error: provide --api-key / EMBY_API_KEY or --username / EMBY_USERNAME",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    configured_user = args.username or None
+    client = EmbyClient(args.server, api_key=args.api_key)
+    probe_kw = {"timeout": INFO_TIMEOUT, "retries": INFO_RETRIES}
+
+    try:
+        user, info = client.probe_session(
+            username=args.username if args.username is not None else None,
+            password=args.password if args.password is not None else "",
+        )
+    except (requests.RequestException, RuntimeError, ValueError, KeyError, TypeError) as exc:
+        user_name = configured_user or "unknown"
+        print(f"user: {user_name}")
+        print(f"url: {client.server_url}")
+        print("server: not validated (name and version unavailable)")
+        print(f"detail: {exc}", file=sys.stderr)
+        return
+
+    user_name = user.get("Name") or configured_user or user.get("Id") or "unknown"
+    user_id = user.get("Id")
+    if user_id:
+        client.user_id = user_id
+
+    print(f"user: {user_name}")
+    print(f"url: {client.server_url}")
+    print(f"server: {info.get('ServerName') or info.get('Id') or 'unknown'}")
+    print(f"version: {info.get('Version') or 'unknown'}")
+
+    os_name = info.get("OperatingSystemDisplayName") or info.get("OperatingSystem")
+    if os_name:
+        print(f"os: {os_name}")
+    server_id = info.get("Id")
+    if server_id:
+        print(f"id: {server_id}")
+    if info.get("HasUpdateAvailable"):
+        print("update: available")
+    if _addr_differs(client.server_url, info.get("LocalAddress")):
+        print(f"local: {info['LocalAddress']}")
+    if _addr_differs(client.server_url, info.get("WanAddress")):
+        print(f"wan: {info['WanAddress']}")
+
+    try:
+        libraries = client.get_libraries(**probe_kw)
+    except (requests.RequestException, RuntimeError, ValueError, KeyError, TypeError):
+        print("libraries: unavailable")
+        libraries = None
+
+    if libraries is not None:
+        names = [lib.get("Name") or lib.get("Id") or "?" for lib in libraries]
+        if names:
+            print(f"libraries: {len(names)} ({', '.join(names)})")
+        else:
+            print("libraries: 0")
+
+    try:
+        counts = client.get_item_counts(user_id=user_id, **probe_kw)
+    except (requests.RequestException, RuntimeError, ValueError, KeyError, TypeError):
+        print("counts: unavailable")
+        return
+
+    for label, key in _PRIMARY_COUNTS:
+        val = counts.get(key)
+        print(f"{label}: {val if val is not None else 'unavailable'}")
+
+    for label, key in _EXTRA_COUNTS:
+        val = counts.get(key)
+        if isinstance(val, int) and val > 0:
+            print(f"{label}: {val}")

emby_cli-0.2.2/src/emby_cli/commands/list.py

@@ -0,0 +1,50 @@
+"""list command."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from emby_cli.client import EmbyClient
+from emby_cli.constants import DOWNLOADABLE_TYPES
+from emby_cli.resolve import print_item_choices, print_library_choices
+
+
+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"])
+        targets = [i for i in items if i.get("Type") in DOWNLOADABLE_TYPES]
+        if not targets:
+            print("No results.")
+            return
+        print_item_choices(targets)
+        print(f"\nTotal: {len(targets)}")
+        print()
+        return
+
+    if not libraries:
+        print("No results.")
+        return
+
+    # Fetch all library counts first, then print one table.
+    rows: list[dict] = []
+    for lib in libraries:
+        page = client.get_items(parent_id=lib["Id"], limit=0)
+        rows.append({
+            "Id": lib.get("Id", ""),
+            "Name": lib.get("Name") or "?",
+            "Type": lib.get("CollectionType") or lib.get("Type") or "Library",
+            "ItemCount": page.get("TotalRecordCount", 0),
+        })
+
+    print_library_choices(rows)
+    print(f"\nTotal: {len(rows)}")
+    print()

{emby_cli-0.2.0 → emby_cli-0.2.2}/src/emby_cli/commands/play.py

@@ -99,7 +99,7 @@ def cmd_play(client: EmbyClient, args: argparse.Namespace) -> None:
             print_error(f"fetching item {item_id}: {exc}")
             sys.exit(1)
     else:
-        pick_best = bool(getattr(args, "pick_best_item", 0))
+        pick_best = bool(getattr(args, "pick_best_item", False))
         item = resolve_title_item(client, query, pick_best=pick_best)
         if item is None:
             sys.exit(1)

emby_cli-0.2.2/src/emby_cli/commands/version.py

@@ -0,0 +1,35 @@
+"""version command."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+import requests
+
+from emby_cli.client import EmbyClient
+from emby_cli.version import get_version
+
+
+def cmd_version(args: argparse.Namespace) -> None:
+    print(f"emby-cli: {get_version()}")
+
+    has_server = bool(getattr(args, "server", None))
+    has_creds = bool(getattr(args, "api_key", None) or getattr(args, "username", None))
+    if not has_server or not has_creds:
+        return
+
+    client = EmbyClient(args.server, api_key=args.api_key)
+    try:
+        _user, info = client.probe_session(
+            username=args.username if args.username is not None else None,
+            password=args.password if args.password is not None else "",
+        )
+    except (requests.RequestException, RuntimeError, ValueError, KeyError, TypeError) as exc:
+        print("server: not validated (name and version unavailable)")
+        print(f"detail: {exc}", file=sys.stderr)
+        return
+
+    name = info.get("ServerName") or info.get("Id") or "Emby"
+    ver = info.get("Version") or "unknown"
+    print(f"server: {ver} ({name})")

{emby_cli-0.2.0 → emby_cli-0.2.2}/src/emby_cli/constants.py

@@ -4,6 +4,9 @@ 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
+# Single-shot probes (version / info): no backoff spam on unreachable servers
+INFO_TIMEOUT = 10  # seconds
+INFO_RETRIES = 1
 CLIENT_NAME = "emby-cli"
 DEVICE_NAME = "emby-cli"
 DEFAULT_OUTPUT = "./downloads"

{emby_cli-0.2.0 → emby_cli-0.2.2}/src/emby_cli/resolve.py

@@ -131,13 +131,42 @@ def print_item_choices(
         )
 
 
+def print_library_choices(libraries: list[dict]) -> None:
+    """Print libraries: ID, Name, Type, Items (no Year/Res/Size)."""
+    if not libraries:
+        return
+    id_w = max(len("ID"), max(len(str(lib.get("Id", ""))) for lib in libraries))
+    name_w = 44
+    type_w = max(len("Type"), max(len(str(lib.get("Type") or "?")) for lib in libraries))
+    items_w = max(len("Items"), 5)
+
+    header = (
+        f"{'ID':<{id_w}}  {'Name':<{name_w}}  {'Type':<{type_w}}  {'Items':>{items_w}}"
+    )
+    print()
+    print(header)
+    print("-" * len(header))
+
+    for lib in libraries:
+        iid = str(lib.get("Id", ""))
+        label = str(lib.get("Name") or "?")
+        if len(label) > name_w:
+            label = label[: name_w - 1] + "…"
+        itype = str(lib.get("Type") or "?")
+        count = lib.get("ItemCount")
+        count_s = str(count) if count is not None else "?"
+        print(
+            f"{iid:<{id_w}}  {label:<{name_w}}  {itype:<{type_w}}  {count_s:>{items_w}}"
+        )
+
+
 def _ambiguous(
     items: list[dict],
     *,
     excluded: set[str] | None = None,
     hint: str = (
         "Use --item-id with an ID from the list above, "
-        "or pass --pick-best-item=1 to auto-select."
+        "or pass --pick-best-item to auto-select."
     ),
 ) -> None:
     print_item_choices(items, excluded=excluded)

emby_cli-0.2.2/tests/test_info.py

@@ -0,0 +1,105 @@
+"""Tests for the info command."""
+
+from __future__ import annotations
+
+import argparse
+from unittest.mock import MagicMock, patch
+
+import pytest
+import requests
+
+from emby_cli.client import EmbyClient
+from emby_cli.commands.info import cmd_info
+
+
+def test_info_requires_server():
+    args = argparse.Namespace(server=None, api_key="k", username=None, password=None)
+    with pytest.raises(SystemExit) as exc:
+        cmd_info(args)
+    assert exc.value.code == 1
+
+
+def test_info_ok(capsys):
+    args = argparse.Namespace(
+        server="http://host:8096",
+        api_key="k",
+        username=None,
+        password=None,
+    )
+    with patch("emby_cli.commands.info.EmbyClient") as cls:
+        client = cls.return_value
+        client.server_url = "http://host:8096"
+        client.probe_session.return_value = (
+            {"Name": "sergio", "Id": "u1"},
+            {
+                "ServerName": "home",
+                "Version": "4.8.0",
+                "OperatingSystemDisplayName": "Linux",
+                "Id": "srv-id",
+                "LocalAddress": "http://192.168.1.1:8096",
+                "WanAddress": "http://example.com:8096",
+                "HasUpdateAvailable": False,
+            },
+        )
+        client.get_libraries.return_value = [
+            {"Name": "Movies", "Id": "1"},
+            {"Name": "TV", "Id": "2"},
+        ]
+        client.get_item_counts.return_value = {
+            "MovieCount": 10,
+            "SeriesCount": 2,
+            "EpisodeCount": 50,
+            "SongCount": 0,
+            "AlbumCount": 0,
+            "BoxSetCount": 3,
+            "BookCount": 0,
+        }
+        cmd_info(args)
+
+    out = capsys.readouterr().out
+    assert "user: sergio" in out
+    assert "url: http://host:8096" in out
+    assert "server: home" in out
+    assert "version: 4.8.0" in out
+    assert "os: Linux" in out
+    assert "id: srv-id" in out
+    assert "local: http://192.168.1.1:8096" in out
+    assert "wan: http://example.com:8096" in out
+    assert "libraries: 2 (Movies, TV)" in out
+    assert "movies: 10" in out
+    assert "series: 2" in out
+    assert "episodes: 50" in out
+    assert "songs: 0" in out
+    assert "albums: 0" in out
+    assert "boxsets: 3" in out
+    assert "books:" not in out
+    assert client.get_item_counts.call_args.kwargs["user_id"] == "u1"
+
+
+def test_info_unreachable_soft(capsys):
+    args = argparse.Namespace(
+        server="http://host:8096",
+        api_key=None,
+        username="u",
+        password="bad",
+    )
+    with patch("emby_cli.commands.info.EmbyClient") as cls:
+        client = cls.return_value
+        client.server_url = "http://host:8096"
+        client.probe_session.side_effect = requests.Timeout("timed out")
+        cmd_info(args)
+    out = capsys.readouterr().out
+    assert "user: u" in out
+    assert "url: http://host:8096" in out
+    assert "server: not validated (name and version unavailable)" in out
+    assert "movies:" not in out
+
+
+def test_get_item_counts_endpoint():
+    client = EmbyClient("http://host:8096", api_key="k")
+    mock_resp = MagicMock()
+    mock_resp.json.return_value = {"MovieCount": 1}
+    with patch.object(client, "_get", return_value=mock_resp) as get:
+        assert client.get_item_counts(user_id="uid")["MovieCount"] == 1
+    assert get.call_args.args[0] == "/Items/Counts"
+    assert get.call_args.kwargs["params"]["UserId"] == "uid"

{emby_cli-0.2.0 → emby_cli-0.2.2}/tests/test_parser.py

@@ -10,7 +10,9 @@ from emby_cli.cli import build_parser
 def test_build_parser_subcommands():
     parser = build_parser()
     subs = parser._subparsers._group_actions[0].choices
-    assert set(subs) == {"list", "download", "search", "play", "sync", "batch"}
+    assert set(subs) == {
+        "list", "download", "search", "play", "sync", "batch", "version", "info",
+    }
 
 
 def test_parser_requires_command():
@@ -30,18 +32,18 @@ def test_batch_has_pick_best_item():
     parser = build_parser()
     args = parser.parse_args([
         "--server", "http://x", "--api-key", "k",
-        "batch", "-F", "titles.txt", "--pick-best-item", "1",
+        "batch", "-F", "titles.txt", "--pick-best-item",
     ])
-    assert args.pick_best_item == 1
+    assert args.pick_best_item is True
 
 
-def test_batch_pick_best_default_zero():
+def test_batch_pick_best_default_false():
     parser = build_parser()
     args = parser.parse_args([
         "--server", "http://x", "--api-key", "k",
         "batch", "-F", "titles.txt",
     ])
-    assert args.pick_best_item == 0
+    assert args.pick_best_item is False
 
 
 def test_batch_requires_file():
@@ -65,3 +67,14 @@ def test_search_count_flag():
         "search", "matrix", "--count", "50",
     ])
     assert args.count == 50
+
+
+def test_version_subcommand_parses_without_server(monkeypatch):
+    monkeypatch.delenv("EMBY_SERVER", raising=False)
+    monkeypatch.delenv("EMBY_API_KEY", raising=False)
+    monkeypatch.delenv("EMBY_USERNAME", raising=False)
+    monkeypatch.delenv("EMBY_PASSWORD", raising=False)
+    parser = build_parser()
+    args = parser.parse_args(["version"])
+    assert args.command == "version"
+    assert args.server is None

emby_cli-0.2.2/tests/test_resolve_table.py

@@ -0,0 +1,42 @@
+"""Tests for item/library table output."""
+
+from __future__ import annotations
+
+from emby_cli.resolve import print_item_choices, print_library_choices
+
+
+def test_print_item_choices_media(capsys):
+    print_item_choices([
+        {
+            "Id": "abc",
+            "Name": "Film",
+            "Type": "Movie",
+            "ProductionYear": 2020,
+            "Width": 1920,
+            "Size": 1024,
+        },
+    ])
+    out = capsys.readouterr().out
+    assert "ID" in out and "Name" in out and "Year" in out and "Size" in out
+    assert "abc" in out
+    assert "Film" in out
+    assert "Movie" in out
+
+
+def test_print_library_choices(capsys):
+    print_library_choices([
+        {
+            "Id": "lib1",
+            "Name": "Movies",
+            "Type": "movies",
+            "ItemCount": 42,
+        },
+    ])
+    out = capsys.readouterr().out
+    assert "Items" in out
+    assert "Year" not in out
+    assert "Res" not in out
+    assert "Size" not in out
+    assert "lib1" in out
+    assert "Movies" in out
+    assert "42" in out

emby_cli-0.2.2/tests/test_version.py

@@ -0,0 +1,127 @@
+"""Tests for the version command."""
+
+from __future__ import annotations
+
+import argparse
+from unittest.mock import MagicMock, patch
+
+import requests
+
+from emby_cli.commands.version import cmd_version
+from emby_cli.client import EmbyClient
+
+
+def test_cmd_version_client_only(capsys):
+    args = argparse.Namespace(server=None, api_key=None, username=None, password=None)
+    with patch("emby_cli.commands.version.get_version", return_value="0.2.0"):
+        cmd_version(args)
+    out = capsys.readouterr().out
+    assert out.strip() == "emby-cli: 0.2.0"
+
+
+def test_cmd_version_with_server(capsys):
+    args = argparse.Namespace(
+        server="http://host:8096",
+        api_key="k",
+        username=None,
+        password=None,
+    )
+    with patch("emby_cli.commands.version.get_version", return_value="0.2.0"):
+        with patch("emby_cli.commands.version.EmbyClient") as cls:
+            client = cls.return_value
+            client.probe_session.return_value = (
+                {"Name": "u"},
+                {"Version": "4.8.10.0", "ServerName": "home"},
+            )
+            cmd_version(args)
+    out = capsys.readouterr().out
+    assert "emby-cli: 0.2.0" in out
+    assert "server: 4.8.10.0 (home)" in out
+
+
+def test_cmd_version_unreachable(capsys):
+    args = argparse.Namespace(
+        server="http://host:8096",
+        api_key=None,
+        username="u",
+        password="bad",
+    )
+    with patch("emby_cli.commands.version.get_version", return_value="0.2.0"):
+        with patch("emby_cli.commands.version.EmbyClient") as cls:
+            client = cls.return_value
+            client.probe_session.side_effect = requests.Timeout("timed out")
+            cmd_version(args)
+    out = capsys.readouterr().out
+    assert "emby-cli: 0.2.0" in out
+    assert "server: not validated (name and version unavailable)" in out
+
+
+def test_get_system_info_endpoint():
+    client = EmbyClient("http://host:8096", api_key="k")
+    mock_resp = MagicMock()
+    mock_resp.json.return_value = {"Version": "4.8.0.0", "ServerName": "x"}
+    with patch.object(client, "_get", return_value=mock_resp) as get:
+        assert client.get_system_info()["Version"] == "4.8.0.0"
+    assert get.call_args.args[0] == "/System/Info"
+
+
+def test_probe_session_falls_back_to_public_system_info():
+    client = EmbyClient("http://host:8096", api_key="k")
+    client.user_id = "u1"
+    me = MagicMock()
+    me.json.return_value = {"Name": "u", "Id": "u1"}
+    public = MagicMock()
+    public.json.return_value = {"ServerName": "home", "Version": "4.8.0"}
+
+    def fake_get(path, **kwargs):
+        if path == "/Users/Me":
+            return me
+        if path == "/System/Info":
+            raise requests.HTTPError("403")
+        if path == "/System/Info/Public":
+            return public
+        raise AssertionError(path)
+
+    with patch.object(client, "_get", side_effect=fake_get):
+        user, info = client.probe_session()
+    assert user["Name"] == "u"
+    assert info["ServerName"] == "home"
+    assert info["Version"] == "4.8.0"
+
+
+def test_probe_session_uses_auth_user_skips_users_me():
+    client = EmbyClient("http://host:8096")
+    auth_user = {"Name": "u", "Id": "abcd" * 8}
+
+    def fake_get(path, **kwargs):
+        if path == "/Users/Me":
+            raise AssertionError("/Users/Me should not be called after auth")
+        if path == "/System/Info":
+            resp = MagicMock()
+            resp.json.return_value = {"ServerName": "home", "Version": "4.8"}
+            return resp
+        raise AssertionError(path)
+
+    with patch.object(client, "authenticate", return_value=auth_user) as auth:
+        with patch.object(client, "_get", side_effect=fake_get):
+            user, info = client.probe_session(username="u", password="p")
+    auth.assert_called_once()
+    assert user is auth_user
+    assert info["ServerName"] == "home"
+
+
+def test_get_current_user_falls_back_to_users_id():
+    client = EmbyClient("http://host:8096", api_key="k")
+    client.user_id = "uid-1"
+    by_id = MagicMock()
+    by_id.json.return_value = {"Name": "u", "Id": "uid-1"}
+
+    def fake_get(path, **kwargs):
+        if path == "/Users/Me":
+            raise requests.HTTPError("500 Guid")
+        if path == "/Users/uid-1":
+            return by_id
+        raise AssertionError(path)
+
+    with patch.object(client, "_get", side_effect=fake_get):
+        assert client.get_current_user()["Name"] == "u"

emby_cli-0.2.0/CHANGELOG.md

@@ -1,11 +0,0 @@
-# Changelog
-
-## Unreleased
-
-## 0.2.0
-
-- API fixes: `get_item_info` Fields, `/Users/Me`, safer 416 resume, `api_key` on play URLs, client version from package, `/emby` base URL normalize, HLS without invalid `copy` codecs, paginated episodes.
-- Shared resolve for `play`/`batch` (strict by default; `--pick-best-item 0|1`).
-- Homogeneous CLI messages (`output.py`); shared library/download loops; non-zero exit on errors / batch not-found.
-- `search`: paginate Emby results (was capped at 25); `--count` / `-n` to limit how many to return (default: all).
-- More tests (`test_client`, `test_output`, parser coverage).

emby_cli-0.2.0/src/emby_cli/commands/list.py

@@ -1,32 +0,0 @@
-"""list command."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-
-from emby_cli.client import EmbyClient
-from emby_cli.constants import DOWNLOADABLE_TYPES
-from emby_cli.resolve import print_item_choices
-
-
-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"])
-        targets = [i for i in items if i.get("Type") in DOWNLOADABLE_TYPES]
-        print_item_choices(targets)
-        print(f"\nTotal downloadable items: {len(targets)}")
-    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()