emby-cli 0.1.0__py3-none-any.whl

emby_cli/resolve.py

@@ -0,0 +1,255 @@
+"""Title-line parsing, resolution ranking, and item resolution for play/batch."""
+
+from __future__ import annotations
+
+import re
+
+from emby_cli.client import EmbyClient
+from emby_cli.util import format_size, item_remote_size
+
+_TITLE_RE = re.compile(
+    r"^(.+?)"              # title (non-greedy)
+    r"(?:\s*\((\d{4})\))?" # optional (YYYY)
+    r"(?:\s+S(\d+)"        # optional S##
+    r"(?:E(\d+))?"         # optional E##
+    r")?$",
+    re.IGNORECASE,
+)
+
+
+def parse_title_line(line: str) -> tuple[str, int | None, int | None, int | None]:
+    """Parse 'Title', 'Title (2010)', 'Title S01', 'Title (2008) S01E05', etc."""
+    line = line.strip()
+    m = _TITLE_RE.match(line)
+    if m:
+        title = m.group(1).strip()
+        year = int(m.group(2)) if m.group(2) else None
+        season = int(m.group(3)) if m.group(3) else None
+        episode = int(m.group(4)) if m.group(4) else None
+        return title, season, episode, year
+    return line, None, None, None
+
+
+def item_video_width(item: dict) -> int | None:
+    w = item.get("Width")
+    if w:
+        return w
+    streams = item.get("MediaStreams", [])
+    if not streams:
+        sources = item.get("MediaSources", [])
+        if sources:
+            streams = sources[0].get("MediaStreams", [])
+    for s in streams:
+        if s.get("Type") == "Video" and s.get("Width"):
+            return s["Width"]
+    return None
+
+
+def classify_resolution(width: int | None) -> str:
+    if width is None:
+        return "?"
+    if width >= 3840:
+        return "4K"
+    if width >= 1920:
+        return "1080p"
+    if width >= 1280:
+        return "720p"
+    return "SD"
+
+
+def pick_best_item(items: list[dict]) -> dict | None:
+    """Pick the best resolution up to 1080p (skip 4K)."""
+    if not items:
+        return None
+    if len(items) == 1:
+        return items[0]
+
+    classified = [(it, item_video_width(it) or 0) for it in items]
+
+    # Prefer 1080p
+    for it, w in classified:
+        if classify_resolution(w) == "1080p":
+            return it
+
+    # Then highest that is NOT 4K (720p, SD, etc.)
+    non_4k = [(it, w) for it, w in classified if classify_resolution(w) != "4K"]
+    if non_4k:
+        non_4k.sort(key=lambda x: x[1], reverse=True)
+        return non_4k[0][0]
+
+    # Only 4K available — take it as last resort
+    classified.sort(key=lambda x: x[1], reverse=True)
+    return classified[0][0]
+
+def item_label(item: dict) -> str:
+    """Human-readable name; episodes include SxxExx prefix."""
+    name = item.get("Name") or "?"
+    if item.get("Type") == "Episode":
+        s, e = item.get("ParentIndexNumber"), item.get("IndexNumber")
+        if s is not None and e is not None:
+            return f"S{s:02d}E{e:02d} {name}"
+    return name
+
+
+def print_item_choices(
+    items: list[dict],
+    *,
+    selected: dict | None = None,
+    excluded: set[str] | None = None,
+) -> None:
+    """Print a compact, uniform table of items (movies, series, episodes)."""
+    if not items:
+        return
+    excluded = excluded or set()
+    id_w = max(len("ID"), max(len(str(it.get("Id", ""))) for it in items))
+    name_w = 44
+
+    header = (
+        f"{'ID':<{id_w}}  {'Name':<{name_w}}  {'Year':<4}  {'Type':<8}  "
+        f"{'Res':>5}  {'Size':>9}  Note"
+    )
+    print()
+    print(header)
+    print("-" * len(header))
+
+    selected_id = selected.get("Id") if selected else None
+    for it in items:
+        iid = str(it.get("Id", ""))
+        label = item_label(it)
+        if len(label) > name_w:
+            label = label[: name_w - 1] + "…"
+        year = str(it.get("ProductionYear") or "?")
+        itype = str(it.get("Type") or "?")
+        res = classify_resolution(item_video_width(it))
+        size = format_size(item_remote_size(it))
+        notes: list[str] = []
+        if selected_id is not None and iid == selected_id:
+            notes.append("selected")
+        if iid in excluded:
+            notes.append("year")
+        note = ", ".join(notes)
+        print(
+            f"{iid:<{id_w}}  {label:<{name_w}}  {year:<4}  {itype:<8}  "
+            f"{res:>5}  {size:>9}  {note}"
+        )
+
+
+def resolve_title_item(
+    client: EmbyClient,
+    raw_line: str,
+    *,
+    pick_best: bool = False,
+) -> dict | None:
+    """Resolve a batch-style title line to one playable item.
+
+    When *pick_best* is True and several candidates remain after title/year
+    filters, chooses the best ≤1080p version (same as ``batch``). When False
+    (default), any ambiguity prints the table and returns None so the user
+    can pass ``--item-id``.
+    """
+    title, season, episode, year = parse_title_line(raw_line)
+
+    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.") -> None:
+        print_item_choices(items, excluded=excluded)
+        print(f"\n{hint}")
+
+    if season is not None:
+        kind = f"S{season:02d}E{episode:02d}" if episode is not None else f"S{season:02d}"
+        label = f"{title} ({year}) {kind}" if year else f"{title} {kind}"
+        print(f"Searching: \"{label}\" (series)")
+
+        series_results = client.search_items(title, item_types="Series")
+        if not series_results:
+            print("No series found.")
+            return None
+
+        candidates = series_results
+        excluded: set[str] = set()
+        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)")
+                excluded = {s["Id"] for s in series_results if s not in year_matches}
+                candidates = year_matches
+            else:
+                print(f"  No series match year {year}.")
+                _ambiguous(series_results)
+                return None
+
+        if len(candidates) > 1:
+            print("  Multiple series matches; pick one with --item-id:")
+            _ambiguous(series_results, excluded=excluded)
+            return None
+
+        series = candidates[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}.")
+            return None
+
+        if episode is None:
+            print(f"  Season {season:02d} has {len(episodes)} episode(s); "
+                  "specify SxxExx or --item-id:")
+            print_item_choices(episodes)
+            return None
+
+        if len(episodes) == 1:
+            return episodes[0]
+
+        if not pick_best:
+            print(f"  {len(episodes)} versions for {kind}; ambiguous:")
+            _ambiguous(episodes)
+            return None
+
+        best = pick_best_item(episodes)
+        if best is None:
+            _ambiguous(episodes)
+            return None
+        print_item_choices(episodes, selected=best)
+        return best
+
+    # Movie path
+    label = f"{title} ({year})" if year else title
+    print(f"Searching: \"{label}\" (movie)")
+    results = client.search_items(title, item_types="Movie")
+    if not results:
+        print("No results found.")
+        return None
+
+    candidates = results
+    excluded: set[str] = set()
+    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)")
+            excluded = {r["Id"] for r in results if r not in year_matches}
+            candidates = year_matches
+        else:
+            print(f"  No results match year {year}.")
+            _ambiguous(results)
+            return None
+
+    if len(candidates) == 1:
+        best = candidates[0]
+        print_item_choices(results, selected=best, excluded=excluded)
+        return best
+
+    if not pick_best:
+        print(f"  {len(candidates)} matches; ambiguous:")
+        _ambiguous(results, excluded=excluded)
+        return None
+
+    best = pick_best_item(candidates)
+    if best is None:
+        _ambiguous(candidates)
+        return None
+
+    print_item_choices(results, selected=best, excluded=excluded)
+    return best

emby_cli/util.py

@@ -0,0 +1,117 @@
+"""Path, size, skip, and ffmpeg helpers."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from emby_cli.constants import TICKS_PER_SECOND
+
+def build_dest_path(item: dict, output_dir: Path) -> Path:
+    """Build a destination path that mirrors the Emby library structure."""
+    server_path = item.get("Path", "")
+    if server_path:
+        # Use the last 2-3 path components (e.g. Movies/Title/file.mkv)
+        parts = Path(server_path).parts
+        # Take from the library-level folder onward (heuristic: skip leading /downloads, /mnt, etc.)
+        relevant = parts[-3:] if len(parts) >= 3 else parts[-2:] if len(parts) >= 2 else parts
+        return output_dir / Path(*relevant)
+
+    name = item.get("Name", item["Id"])
+    ext = ".mkv"
+    sources = item.get("MediaSources", [])
+    if sources and sources[0].get("Container"):
+        ext = "." + sources[0]["Container"]
+    return output_dir / f"{name}{ext}"
+
+
+def item_duration_seconds(item: dict) -> float | None:
+    ticks = item.get("RunTimeTicks")
+    if ticks:
+        return ticks / TICKS_PER_SECOND
+    return None
+
+
+def item_playback_rate(item: dict) -> float | None:
+    """Bytes per second that matches real-time playback speed."""
+    size = item_remote_size(item)
+    duration = item_duration_seconds(item)
+    if size and duration and duration > 0:
+        return size / duration
+    return None
+
+
+def format_duration(seconds: float | None) -> str:
+    if seconds is None:
+        return "?"
+    h, rem = divmod(int(seconds), 3600)
+    m, s = divmod(rem, 60)
+    if h:
+        return f"{h}h{m:02d}m"
+    return f"{m}m{s:02d}s"
+
+
+def item_remote_size(item: dict) -> int | None:
+    sources = item.get("MediaSources", [])
+    if sources:
+        return sources[0].get("Size")
+    return None
+
+
+def format_size(n: int | None) -> str:
+    if n is None:
+        return "?"
+    for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+        if abs(n) < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024  # type: ignore[assignment]
+    return f"{n:.1f} PiB"
+
+
+def should_skip(item: dict, dest: Path) -> bool:
+    """Return True when the local file already matches the remote size."""
+    if not dest.exists():
+        return False
+    remote_size = item_remote_size(item)
+    if remote_size is None:
+        return False
+    return dest.stat().st_size == remote_size
+
+
+def should_skip_hls(dest: Path) -> bool:
+    """Skip only if the .mkv AND its .done marker both exist."""
+    mkv = dest.with_suffix(".mkv")
+    done = Path(str(mkv) + ".done")
+    return mkv.exists() and done.exists()
+
+
+def ffmpeg_exe() -> str:
+    """Return the bundled static-ffmpeg binary (never the system PATH)."""
+    try:
+        from static_ffmpeg.run import get_or_fetch_platform_executables_else_raise
+    except ImportError as exc:
+        raise RuntimeError(
+            "static-ffmpeg is required for HLS remux. "
+            "Install it with: pip install static-ffmpeg"
+        ) from exc
+    ffmpeg_path, _ = get_or_fetch_platform_executables_else_raise()
+    return ffmpeg_path
+
+
+def remux_segments(tmp_dir: Path, segments: list[Path], dest_path: Path) -> None:
+    """Concatenate .ts segments into a single .mkv using bundled ffmpeg -c copy."""
+    concat_file = tmp_dir / "concat.txt"
+    with open(concat_file, "w") as f:
+        for seg in segments:
+            f.write(f"file '{seg.resolve()}'\n")
+
+    cmd = [
+        ffmpeg_exe(), "-y", "-hide_banner", "-loglevel", "warning",
+        "-f", "concat", "-safe", "0",
+        "-i", str(concat_file),
+        "-c", "copy",
+        str(dest_path),
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg remux failed:\n{result.stderr}")

emby_cli/version.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+def get_version() -> str:
+    try:
+        from emby_cli._version import __version__
+
+        return __version__
+    except ImportError:
+        pass
+
+    try:
+        from importlib.metadata import version
+
+        return version("emby-cli")
+    except Exception:
+        return "unknown"

emby_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: emby-cli
+Version: 0.1.0
+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
+Project-URL: Issues, https://github.com/soukron/emby-cli/issues
+Author-email: Sergio Garcia <soukron@gmbros.net>
+Maintainer-email: Sergio Garcia <soukron@gmbros.net>
+License-Expression: CC-BY-NC-4.0
+License-File: LICENSE
+Keywords: backup,cli,download,emby,media
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: Free for non-commercial use
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.9
+Requires-Dist: m3u8>=4.0
+Requires-Dist: requests>=2.31
+Requires-Dist: static-ffmpeg>=3.0
+Requires-Dist: tqdm>=4.66
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# emby-cli
+
+[PyPI](https://pypi.org/project/emby-cli/)
+[License: CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)
+
+CLI to **list, search, play, and download/backup** original media files from an [Emby](https://emby.media/) server via its REST API. Only HTTP access is required (default port 8096) — no SSH or rsync.
+
+## Install
+
+```bash
+pip install emby-cli
+```
+
+Development (from a clone of this repo):
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+In the gmbros.net ops tree (`emby-downloader/`), use the root Makefile instead:
+
+```bash
+cd ~/.local/gmbros.net/emby-downloader
+make install
+```
+
+## Configuration
+
+Set environment variables (or pass CLI flags):
+
+| Variable | Description |
+|----------|-------------|
+| `EMBY_SERVER` | Server URL (required) |
+| `EMBY_API_KEY` | API key (or use username/password) |
+| `EMBY_USERNAME` / `EMBY_PASSWORD` | Name/password auth |
+| `EMBY_OUTPUT` | Download directory (default `./downloads`) |
+| `EMBY_METHOD` | `download`, `stream`, or `hls` |
+| `EMBY_PLAYER` | External player for `play` |
+
+See `.env.example`. The app does not load `.env` itself — `source` it or export vars.
+
+## Usage
+
+```bash
+emby-cli list
+emby-cli search "Title"
+emby-cli download -i <itemId> -o ./downloads
+emby-cli sync -l "Movies"
+emby-cli batch -F titles.txt -n
+emby-cli play "Movie (2010)"
+```
+
+Download methods (`-m` / `EMBY_METHOD`):
+
+- `download` — `GET /Items/{id}/Download`
+- `stream` — DirectStreamUrl / `original.*` (Emby Web style)
+- `hls` — HLS segments remuxed to `.mkv` (needs `static-ffmpeg`)
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest -q
+python -m build && twine check dist/*
+```
+
+Ops Makefile (gmbros.net host only, not in this repo):
+
+```bash
+cd ~/.local/gmbros.net/emby-downloader
+make install / make test / make build / make check
+make push
+make release VERSION=0.1.0   # tag + gh release → CI publishes to PyPI
+```
+
+## License
+
+[CC BY-NC 4.0](https://creativecommons.org/licenses/by-nc/4.0/)

emby_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+src/emby_cli/__init__.py,sha256=-uPhkssq9ItB8QL5Wylev3g91Oxry2WVa1BnCJ6uzJ0,186
+src/emby_cli/__main__.py,sha256=-FUM3SSVm-uufrAezbyW2jy7DZTenot0u5dqTo5hNwA,69
+src/emby_cli/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+src/emby_cli/cli.py,sha256=5KvYNjemPHemHnKTnFZ9ff06tGXALd4CcC1KEh8BZ70,6885
+src/emby_cli/client.py,sha256=yWI8UAwTNT9fPrVQx9b7J9YpKZYC9FJiNWosZWmQYsQ,18664
+src/emby_cli/constants.py,sha256=Bd_b4QgxtSvRc1XuaPyXV8BIawDhywEkNAczchrHuDw,325
+src/emby_cli/download_ops.py,sha256=So_i-oejlDfqKBAjM5raPyqRB8RPR4Bdcy6btX8ohrQ,1442
+src/emby_cli/resolve.py,sha256=9OZzuK85XWTc4EXZ9mLztWA05rLhQL3fiMmJIC1NmvY,8406
+src/emby_cli/util.py,sha256=1kKLfVi-TIkSYS-dxWo7K91kxAVz4t-LyB-ATdfHEDQ,3760
+src/emby_cli/version.py,sha256=FTuuw2a_2bAbBZqXmSjPtiCyDe94eMQV-6gR5r1R5oU,327
+src/emby_cli/commands/__init__.py,sha256=TOMJAh6GCkJ3gAlu1iZo1eKtdBP7_MzCeUrxozBCW2Y,28
+src/emby_cli/commands/batch.py,sha256=9bksmor_kY18WnVcLMX1Ti5kIb8TWCj_YWGsEULwxJE,10549
+src/emby_cli/commands/download.py,sha256=SMqO8pA2jAnF389iItuTAXJhVhtU8I93aNbLgN34mv8,2700
+src/emby_cli/commands/list.py,sha256=g7sjQJDtuY1CHAB_uGbEDr_RBUXId3o_qWH2y6jTI3c,1375
+src/emby_cli/commands/play.py,sha256=Fs0i2GkBLtqlMuD3-vfOWIKNuoe6nOp1vu06-K_JpvI,4019
+src/emby_cli/commands/search.py,sha256=eyJvyFwUNR1dbTXHRB--ELQvWVpH4y1x3tV_JQWgHMw,896
+src/emby_cli/commands/sync.py,sha256=vA58xepHbS_4HMFsWW4lfz3qy_3l_ZZe3WkkkE9LHe0,1852
+emby_cli/__init__.py,sha256=-uPhkssq9ItB8QL5Wylev3g91Oxry2WVa1BnCJ6uzJ0,186
+emby_cli/__main__.py,sha256=-FUM3SSVm-uufrAezbyW2jy7DZTenot0u5dqTo5hNwA,69
+emby_cli/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+emby_cli/cli.py,sha256=5KvYNjemPHemHnKTnFZ9ff06tGXALd4CcC1KEh8BZ70,6885
+emby_cli/client.py,sha256=yWI8UAwTNT9fPrVQx9b7J9YpKZYC9FJiNWosZWmQYsQ,18664
+emby_cli/constants.py,sha256=Bd_b4QgxtSvRc1XuaPyXV8BIawDhywEkNAczchrHuDw,325
+emby_cli/download_ops.py,sha256=So_i-oejlDfqKBAjM5raPyqRB8RPR4Bdcy6btX8ohrQ,1442
+emby_cli/resolve.py,sha256=9OZzuK85XWTc4EXZ9mLztWA05rLhQL3fiMmJIC1NmvY,8406
+emby_cli/util.py,sha256=1kKLfVi-TIkSYS-dxWo7K91kxAVz4t-LyB-ATdfHEDQ,3760
+emby_cli/version.py,sha256=FTuuw2a_2bAbBZqXmSjPtiCyDe94eMQV-6gR5r1R5oU,327
+emby_cli/commands/__init__.py,sha256=TOMJAh6GCkJ3gAlu1iZo1eKtdBP7_MzCeUrxozBCW2Y,28
+emby_cli/commands/batch.py,sha256=9bksmor_kY18WnVcLMX1Ti5kIb8TWCj_YWGsEULwxJE,10549
+emby_cli/commands/download.py,sha256=SMqO8pA2jAnF389iItuTAXJhVhtU8I93aNbLgN34mv8,2700
+emby_cli/commands/list.py,sha256=g7sjQJDtuY1CHAB_uGbEDr_RBUXId3o_qWH2y6jTI3c,1375
+emby_cli/commands/play.py,sha256=Fs0i2GkBLtqlMuD3-vfOWIKNuoe6nOp1vu06-K_JpvI,4019
+emby_cli/commands/search.py,sha256=eyJvyFwUNR1dbTXHRB--ELQvWVpH4y1x3tV_JQWgHMw,896
+emby_cli/commands/sync.py,sha256=vA58xepHbS_4HMFsWW4lfz3qy_3l_ZZe3WkkkE9LHe0,1852
+emby_cli-0.1.0.dist-info/METADATA,sha256=azP6xcnde6BmA1ET-s4GnDOVpEIr6xA27fQoSGxqtVM,3400
+emby_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+emby_cli-0.1.0.dist-info/entry_points.txt,sha256=bo4U_yomvNRh3GOmtJn1JOcFJB6S15TMLKZMRIv-Yos,47
+emby_cli-0.1.0.dist-info/licenses/LICENSE,sha256=AUjowifY4qllx1vIGnPthpe4JEPpjJo77U21Ycd-hww,833
+emby_cli-0.1.0.dist-info/RECORD,,

emby_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

emby_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+emby-cli = emby_cli.cli:main

emby_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+Creative Commons Attribution-NonCommercial 4.0 International
+
+Copyright (c) 2026 Sergio Garcia <soukron@gmbros.net>
+
+This work is licensed under the Creative Commons Attribution-NonCommercial
+4.0 International License.
+
+You are free to:
+  - Share — copy and redistribute the material in any medium or format
+  - Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+  - Attribution — You must give appropriate credit, provide a link to the
+    license, and indicate if changes were made.
+  - NonCommercial — You may not use the material for commercial purposes.
+
+No additional restrictions — You may not apply legal terms or technological
+measures that legally restrict others from doing anything the license permits.
+
+Full license text: https://creativecommons.org/licenses/by-nc/4.0/legalcode

src/emby_cli/__init__.py

@@ -0,0 +1,6 @@
+"""emby-cli — backup and stream media from an Emby server."""
+
+from emby_cli.client import EmbyClient
+from emby_cli.version import get_version
+
+__all__ = ["EmbyClient", "get_version"]

src/emby_cli/__main__.py

@@ -0,0 +1,4 @@
+from emby_cli.cli import main
+
+if __name__ == "__main__":
+    main()

src/emby_cli/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None