pymcap-cli 0.13.0__tar.gz → 0.14.0__tar.gz

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymcap-cli
-Version: 0.13.0
+Version: 0.14.0
 Summary: High-performance Python CLI for MCAP file processing with advanced recovery, filtering, and optimization capabilities
 Keywords: mcap,cli,robotics,ros,ros2,recovery,filtering,compression
 Author: Marko Bausch
@@ -29,7 +29,7 @@ Requires-Dist: ros-parser
 Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: typing-extensions>=4.15.0
-Requires-Dist: pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash] ; extra == 'all'
+Requires-Dist: pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash,serve] ; extra == 'all'
 Requires-Dist: robo-ws-bridge ; extra == 'bridge'
 Requires-Dist: mcap-codec-support[draco] ; extra == 'draco'
 Requires-Dist: pillow>=10.0 ; extra == 'image'
@@ -39,6 +39,12 @@ Requires-Dist: numpy>=1.24.0 ; extra == 'parquet'
 Requires-Dist: mcap-codec-support[pointcloud] ; extra == 'parquet'
 Requires-Dist: plotly>=6.0.0 ; extra == 'plot'
 Requires-Dist: mcap-codec-support[pointcloud] ; extra == 'pointcloud'
+Requires-Dist: datasette>=0.65.2,<1 ; extra == 'serve'
+Requires-Dist: datasette-block-robots>=1.1,<2 ; extra == 'serve'
+Requires-Dist: datasette-copyable>=0.3.2,<1 ; extra == 'serve'
+Requires-Dist: datasette-dashboards>=0.8.0,<1 ; extra == 'serve'
+Requires-Dist: datasette-export-notebook>=1.0.1,<2 ; extra == 'serve'
+Requires-Dist: datasette-vega>=0.6.2,<1 ; extra == 'serve'
 Requires-Dist: mcap-codec-support[video] ; extra == 'video'
 Requires-Dist: xxhash>=3.0.0 ; extra == 'xxhash'
 Requires-Python: >=3.10
@@ -53,6 +59,7 @@ Provides-Extra: lite
 Provides-Extra: parquet
 Provides-Extra: plot
 Provides-Extra: pointcloud
+Provides-Extra: serve
 Provides-Extra: video
 Provides-Extra: xxhash
 Description-Content-Type: text/markdown
@@ -415,6 +422,13 @@ Change MCAP file compression.
 ```bash
 pymcap-cli compress input.mcap -o output.mcap --compression zstd
 pymcap-cli compress input.mcap -o output.mcap --compression lz4
+
+# Compress in place: write to a temp file, validate it, then replace the source
+pymcap-cli compress input.mcap --in-place --compression zstd
+
+# Trade a little ratio for throughput: --fast (zstd fast mode), or pick a level
+pymcap-cli compress input.mcap -o output.mcap --fast
+pymcap-cli compress input.mcap -o output.mcap --compression-level -5
 ```
 
 ### `du` — Disk Usage Analysis
@@ -524,8 +538,22 @@ pymcap-cli index tree /data/recordings --max-depth 3
 # Query by topic/schema/time and inspect catalog-wide topics
 pymcap-cli index query /data/recordings --topic /camera/front --format json
 pymcap-cli index topics /camera --sort-by messages
+
+# Apply pending schema migrations to an existing catalog
+pymcap-cli index migrate
+
+# Browse the catalog in a local Datasette web UI (dashboards, charts, cross-links)
+pymcap-cli index serve
 ```
 
+`index serve` launches [Datasette](https://datasette.io/) against the sidecar DB
+with bundled dashboards, canned queries, and a render plugin. It needs the
+`serve` extra (`pip install 'pymcap-cli[serve]'`; in this workspace, use
+`uv run --package pymcap-cli --extra serve pymcap-cli index serve`). Datasette
+runs from the same environment so the plugin resolves. Use `--db` to point at a
+non-default catalog, `--port` to change the port (default 8001), and
+`--no-browser` to skip auto-open.
+
 ### `records` — Raw Record Dump
 
 Print every MCAP record in file order using its `repr`. Useful for inspecting

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/README.md

@@ -356,6 +356,13 @@ Change MCAP file compression.
 ```bash
 pymcap-cli compress input.mcap -o output.mcap --compression zstd
 pymcap-cli compress input.mcap -o output.mcap --compression lz4
+
+# Compress in place: write to a temp file, validate it, then replace the source
+pymcap-cli compress input.mcap --in-place --compression zstd
+
+# Trade a little ratio for throughput: --fast (zstd fast mode), or pick a level
+pymcap-cli compress input.mcap -o output.mcap --fast
+pymcap-cli compress input.mcap -o output.mcap --compression-level -5
 ```
 
 ### `du` — Disk Usage Analysis
@@ -465,8 +472,22 @@ pymcap-cli index tree /data/recordings --max-depth 3
 # Query by topic/schema/time and inspect catalog-wide topics
 pymcap-cli index query /data/recordings --topic /camera/front --format json
 pymcap-cli index topics /camera --sort-by messages
+
+# Apply pending schema migrations to an existing catalog
+pymcap-cli index migrate
+
+# Browse the catalog in a local Datasette web UI (dashboards, charts, cross-links)
+pymcap-cli index serve
 ```
 
+`index serve` launches [Datasette](https://datasette.io/) against the sidecar DB
+with bundled dashboards, canned queries, and a render plugin. It needs the
+`serve` extra (`pip install 'pymcap-cli[serve]'`; in this workspace, use
+`uv run --package pymcap-cli --extra serve pymcap-cli index serve`). Datasette
+runs from the same environment so the plugin resolves. Use `--db` to point at a
+non-default catalog, `--port` to change the port (default 8001), and
+`--no-browser` to skip auto-open.
+
 ### `records` — Raw Record Dump
 
 Print every MCAP record in file order using its `repr`. Useful for inspecting

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymcap-cli"
-version = "0.13.0"
+version = "0.14.0"
 description = "High-performance Python CLI for MCAP file processing with advanced recovery, filtering, and optimization capabilities"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -46,7 +46,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-all = ["pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash]"]
+all = ["pymcap-cli[video,pointcloud,plot,parquet,image,draco,bridge,xxhash,serve]"]
 lite = ["pymcap-cli[image,draco,bridge,xxhash]"]
 bridge = ["robo-ws-bridge"]
 draco = ["mcap-codec-support[draco]"]
@@ -56,6 +56,16 @@ plot = ["plotly>=6.0.0"]
 pointcloud = ["mcap-codec-support[pointcloud]"]
 video = ["mcap-codec-support[video]"]
 xxhash = ["xxhash>=3.0.0"]
+# `index serve` web UI. datasette<1 pin: datasette-dashboards 500s on the 1.0
+# pre-release. Run from the same env so the bundled pymcap_render plugin imports.
+serve = [
+    "datasette>=0.65.2,<1",
+    "datasette-block-robots>=1.1,<2",
+    "datasette-copyable>=0.3.2,<1",
+    "datasette-dashboards>=0.8.0,<1",
+    "datasette-export-notebook>=1.0.1,<2",
+    "datasette-vega>=0.6.2,<1",
+]
 
 
 [project.urls]

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/src/pymcap_cli/cmd/_run_processor.py

@@ -126,6 +126,27 @@ def delete_source_files(sources: list[str], outputs: list[Path]) -> None:
             logger.exception(f"Failed to delete '{src}'")
 
 
+def in_place_temp_path(source: Path) -> Path:
+    """Temp output path next to ``source`` so the final rename stays on one filesystem."""
+    return source.with_name(source.name + ".tmp")
+
+
+def finalize_replace_source(*, source: Path, tmp_output: Path) -> int:
+    """Validate ``tmp_output`` and atomically replace ``source`` with it.
+
+    Returns 0 on success and 1 if validation failed (source is preserved and
+    the temp file is removed).
+    """
+    if not validate_mcap_output(tmp_output):
+        logger.error(f"[red]Output failed validation: {tmp_output}[/red]")
+        logger.error("Source file preserved — output not safe to replace source.")
+        tmp_output.unlink(missing_ok=True)
+        return 1
+    tmp_output.replace(source)
+    logger.info(f"Replaced source: {source}")
+    return 0
+
+
 def finalize_delete_source(
     *,
     sources: list[str],

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/src/pymcap_cli/cmd/bag2mcap_cmd.py

@@ -37,6 +37,7 @@ class Bag2McapOptions:
     compression: WriterCompression = DEFAULT_COMPRESSION
     enable_crcs: bool = True
     use_chunking: bool = True
+    zstd_level: int | None = None
 
 
 @dataclass

pymcap_cli-0.14.0/src/pymcap_cli/cmd/compress_cmd.py

@@ -0,0 +1,152 @@
+"""Compress command for pymcap-cli."""
+
+import logging
+from pathlib import Path
+from urllib.parse import urlparse
+
+from rich.console import Console
+
+from pymcap_cli.cmd._run_processor import (
+    finalize_delete_source,
+    finalize_replace_source,
+    in_place_temp_path,
+    resolve_overwrite_policy,
+    run_processor,
+)
+from pymcap_cli.constants import DEFAULT_CHUNK_SIZE, DEFAULT_COMPRESSION
+from pymcap_cli.core.mcap_processor import (
+    InputOptions,
+    OutputOptions,
+    OverwriteCollisionPolicy,
+)
+from pymcap_cli.types.types_manual import (
+    ChunkSizeOption,
+    CompressionLevelOption,
+    CompressionOption,
+    DeleteSourceOption,
+    FastCompressionOption,
+    ForceOverwriteOption,
+    InPlaceOption,
+    NoClobberOption,
+    OutputPathOption,
+)
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+# zstd "fast" mode: a negative level trades ~5% larger output for roughly 2x
+# compression throughput. Used by --fast.
+_FAST_ZSTD_LEVEL = -1
+
+
+def compress(
+    file: str,
+    output: OutputPathOption | None = None,
+    *,
+    chunk_size: ChunkSizeOption = DEFAULT_CHUNK_SIZE,
+    compression: CompressionOption = DEFAULT_COMPRESSION,
+    force: ForceOverwriteOption = False,
+    no_clobber: NoClobberOption = False,
+    delete_source: DeleteSourceOption = False,
+    in_place: InPlaceOption = False,
+    compression_level: CompressionLevelOption = None,
+    fast: FastCompressionOption = False,
+) -> int:
+    """Create a compressed copy of an MCAP file.
+
+    Copy data in an MCAP file to a new file, compressing the output.
+
+    Parameters
+    ----------
+    file
+        Path to the MCAP file to compress (local file or HTTP/HTTPS URL).
+    output
+        Output filename. Required unless --in-place is given.
+    chunk_size
+        Chunk size of output file in bytes.
+    compression
+        Compression algorithm for output file.
+    force
+        Force overwrite of output file without confirmation.
+    no_clobber
+        Fail instead of prompting if the output file already exists.
+    delete_source
+        Delete source file(s) after the output is validated (header + summary).
+        URL inputs and any source whose path equals the output are skipped.
+    in_place
+        Compress to a temp file next to the source and, after the output is
+        validated (header + summary), atomically replace the source with it.
+        Local files only; mutually exclusive with --output and --delete-source.
+    compression_level
+        zstd level. Omit for the library default (3). Negative levels select the
+        fast modes — much higher throughput for slightly larger output. Ignored
+        for non-zstd compression. Mutually exclusive with --fast.
+    fast
+        Shortcut for a fast zstd level (roughly 2x throughput, ~5% larger
+        output). Equivalent to ``--compression-level -1``.
+
+    Examples
+    --------
+    ```
+    pymcap-cli compress in.mcap -o out.mcap
+    pymcap-cli compress in.mcap --in-place
+    pymcap-cli compress in.mcap -o out.mcap --fast
+    ```
+    """
+    if fast and compression_level is not None:
+        logger.error("--fast and --compression-level cannot be used together.")
+        return 1
+    zstd_level = _FAST_ZSTD_LEVEL if fast else compression_level
+    if in_place:
+        if output is not None:
+            logger.error("--in-place and --output cannot be used together.")
+            return 1
+        if delete_source:
+            logger.error("--in-place and --delete-source cannot be used together.")
+            return 1
+        if urlparse(file).scheme in ("http", "https"):
+            logger.error("--in-place requires a local file, not a URL.")
+            return 1
+        output = in_place_temp_path(Path(file))
+        overwrite_policy = OverwriteCollisionPolicy.OVERWRITE
+    else:
+        if output is None:
+            logger.error("Either --output or --in-place is required.")
+            return 1
+        policy = resolve_overwrite_policy(force=force, no_clobber=no_clobber)
+        if policy is None:
+            logger.error("--force and --no-clobber cannot be used together.")
+            return 1
+        overwrite_policy = policy
+
+    logger.info(f"Compressing '{file}' to '{output}'")
+
+    try:
+        result = run_processor(
+            files=[file],
+            output=output,
+            # Do not force always_decode_chunk — the processor now has a
+            # chunk-level RECOMPRESS path that avoids per-message parsing.
+            input_options=InputOptions.from_args(),
+            output_options=OutputOptions(
+                compression=compression,
+                chunk_size=chunk_size,
+                overwrite_policy=overwrite_policy,
+                zstd_level=zstd_level,
+            ),
+        )
+        logger.info("[green]✓ Compression completed successfully![/green]")
+        console.print(result.stats)
+    except Exception:
+        logger.exception("Error during compression")
+        if in_place:
+            output.unlink(missing_ok=True)
+        return 1
+
+    if in_place:
+        return finalize_replace_source(source=Path(file), tmp_output=output)
+
+    if delete_source:
+        return finalize_delete_source(sources=[file], outputs=[output])
+
+    return 0

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/src/pymcap_cli/cmd/convert_cmd.py

@@ -43,6 +43,7 @@ class ConvertOptions:
     compression: WriterCompression = DEFAULT_COMPRESSION
     enable_crcs: bool = True
     use_chunking: bool = True
+    zstd_level: int | None = None
 
 
 @dataclass

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/src/pymcap_cli/cmd/index/__init__.py

@@ -12,9 +12,11 @@ from cyclopts import App
 from pymcap_cli.cmd.index.duplicates_cmd import duplicates_cmd
 from pymcap_cli.cmd.index.errors_cmd import errors_cmd
 from pymcap_cli.cmd.index.info_cmd import info_cmd
+from pymcap_cli.cmd.index.migrate_cmd import migrate_cmd
 from pymcap_cli.cmd.index.query_cmd import query_cmd
 from pymcap_cli.cmd.index.scan_cmd import scan_cmd
 from pymcap_cli.cmd.index.schemas_cmd import schemas_cmd
+from pymcap_cli.cmd.index.serve_cmd import index_serve
 from pymcap_cli.cmd.index.sessions_cmd import sessions_cmd
 from pymcap_cli.cmd.index.status_cmd import status_cmd
 from pymcap_cli.cmd.index.timeline_cmd import timeline_cmd
@@ -39,3 +41,5 @@ index_app.command(sessions_cmd, name="sessions")
 index_app.command(errors_cmd, name="errors")
 index_app.command(timeline_cmd, name="timeline")
 index_app.command(info_cmd, name="info")
+index_app.command(migrate_cmd, name="migrate")
+index_app.command(index_serve, name="serve")

pymcap_cli-0.14.0/src/pymcap_cli/cmd/index/migrate_cmd.py

@@ -0,0 +1,73 @@
+"""``pymcap-cli index migrate`` — apply pending schema migrations."""
+
+import sqlite3
+from pathlib import Path
+from typing import Annotated
+
+from cyclopts import Parameter
+from rich.table import Table
+
+from pymcap_cli.cmd.index._helpers import _resolve_db, console
+from pymcap_cli.index.db import CURRENT_SCHEMA_VERSION, connect
+
+
+def _read_user_version(db_path: Path) -> int:
+    uri = f"{db_path.resolve().as_uri()}?mode=ro"
+    conn = sqlite3.connect(uri, uri=True, timeout=30.0)
+    try:
+        return int(conn.execute("PRAGMA user_version").fetchone()[0])
+    finally:
+        conn.close()
+
+
+def migrate_cmd(
+    *,
+    db: Annotated[
+        Path | None,
+        Parameter(name=["--db"], help="Override the sidecar DB path."),
+    ] = None,
+) -> int:
+    """Apply any pending schema migrations to the index DB."""
+    db_path = _resolve_db(db)
+    if not db_path.exists():
+        console.print(f"[red]Error:[/] no index DB at {db_path}")
+        return 1
+
+    before = _read_user_version(db_path)
+    if before == CURRENT_SCHEMA_VERSION:
+        console.print(
+            f"Index DB at [cyan]{db_path}[/] is already at schema "
+            f"[green]v{CURRENT_SCHEMA_VERSION}[/]; nothing to do."
+        )
+        return 0
+    if before > CURRENT_SCHEMA_VERSION:
+        console.print(
+            f"[yellow]Index DB at {db_path} is at v{before}, newer than this CLI's "
+            f"v{CURRENT_SCHEMA_VERSION}; refusing to downgrade.[/]"
+        )
+        return 1
+
+    conn = connect(db_path, read_only=False)
+    try:
+        rows = conn.execute(
+            "SELECT version, applied_at, description "
+            "FROM schema_migrations "
+            "WHERE version > ? "
+            "ORDER BY version",
+            (before,),
+        ).fetchall()
+    finally:
+        conn.close()
+
+    console.print(
+        f"Migrated [cyan]{db_path}[/] from "
+        f"[yellow]v{before}[/] to [green]v{CURRENT_SCHEMA_VERSION}[/]."
+    )
+    if rows:
+        table = Table(title=f"Applied migrations ({len(rows)})")
+        table.add_column("Version", justify="right", style="cyan")
+        table.add_column("Description")
+        for version, _applied_at, description in rows:
+            table.add_row(f"v{version:04d}", str(description or "-"))
+        console.print(table)
+    return 0

pymcap_cli-0.14.0/src/pymcap_cli/cmd/index/serve_cmd.py

@@ -0,0 +1,195 @@
+"""``pymcap-cli index serve`` — browse the sidecar catalog with Datasette.
+
+Launches Datasette against the index DB from the *same* interpreter
+(``sys.executable -m datasette``), so the bundled ``pymcap_render`` plugin can
+``import pymcap_cli``. Datasette and its plugins ship in the ``serve`` extra
+(``pip install 'pymcap-cli[serve]'``).
+"""
+
+import importlib.resources
+import importlib.util
+import shutil
+import subprocess
+import sys
+import tempfile
+from contextlib import ExitStack
+from pathlib import Path
+from typing import Annotated
+
+from cyclopts import Group, Parameter
+
+from pymcap_cli.cmd.index._helpers import _print_db_needs_migration, _resolve_db
+from pymcap_cli.index.db import IndexDbNeedsMigrationError, connect
+from pymcap_cli.log_setup import ERR
+
+INDEX_SERVE_OPTIONS_GROUP = Group("Index Serve Options")
+
+
+def _build_datasette_argv(
+    db_link: Path,
+    metadata: Path,
+    plugins_dir: Path,
+    template_dir: Path,
+    host: str,
+    port: int,
+    *,
+    open_browser: bool,
+) -> list[str]:
+    """Assemble the ``python -m datasette serve …`` command line."""
+    argv = [
+        sys.executable,
+        "-m",
+        "datasette",
+        "serve",
+        str(db_link),
+        "--metadata",
+        str(metadata),
+        "--plugins-dir",
+        str(plugins_dir),
+        "--template-dir",
+        str(template_dir),
+        "--setting",
+        "sql_time_limit_ms",
+        "10000",
+        "--setting",
+        "allow_download",
+        "off",
+        "--setting",
+        "default_cache_ttl",
+        "0",
+        "--host",
+        host,
+        "--port",
+        str(port),
+    ]
+    if open_browser:
+        argv.append("-o")
+    return argv
+
+
+def _datasette_is_installed() -> bool:
+    return importlib.util.find_spec("datasette") is not None
+
+
+def _create_stable_db_link(db_path: Path, db_link: Path) -> None:
+    """Create a stable Datasette DB path, falling back when symlinks are unavailable."""
+    resolved = db_path.resolve()
+    try:
+        db_link.symlink_to(resolved)
+    except OSError:
+        pass
+    else:
+        return
+
+    try:
+        db_link.hardlink_to(resolved)
+    except OSError:
+        shutil.copy2(resolved, db_link)
+    else:
+        return
+
+
+def _validate_db_readable(db_path: Path) -> bool:
+    try:
+        conn = connect(db_path, read_only=True)
+    except IndexDbNeedsMigrationError as exc:
+        _print_db_needs_migration(exc)
+        return False
+    except RuntimeError as exc:
+        ERR.print(f"[red]Error:[/red] {exc}")
+        return False
+    else:
+        conn.close()
+        return True
+
+
+def index_serve(
+    *,
+    db: Annotated[
+        Path | None,
+        Parameter(
+            name=["--db"],
+            group=INDEX_SERVE_OPTIONS_GROUP,
+            help="Override the sidecar DB path.",
+        ),
+    ] = None,
+    host: Annotated[
+        str,
+        Parameter(
+            name=["--host"],
+            group=INDEX_SERVE_OPTIONS_GROUP,
+            help="Interface to bind the server to.",
+        ),
+    ] = "127.0.0.1",
+    port: Annotated[
+        int,
+        Parameter(
+            name=["--port", "-p"],
+            group=INDEX_SERVE_OPTIONS_GROUP,
+            help="TCP port to listen on.",
+        ),
+    ] = 8001,
+    no_browser: Annotated[
+        bool,
+        Parameter(
+            name=["--no-browser"],
+            group=INDEX_SERVE_OPTIONS_GROUP,
+            help="Don't auto-open a browser tab on start.",
+            negative="",
+        ),
+    ] = False,
+) -> int:
+    """Browse the index catalog in a local Datasette web UI.
+
+    Serves the sidecar DB read-only with the bundled metadata, dashboards, and
+    ``pymcap_render`` plugin. Needs the ``serve`` extra
+    (``pip install 'pymcap-cli[serve]'``).
+    """
+    db_path = _resolve_db(db)
+    if not db_path.exists():
+        ERR.print(f"[red]Error:[/red] no index DB at {db_path}")
+        return 1
+
+    if not _datasette_is_installed():
+        ERR.print(
+            "[red]Error:[/red] Datasette is not installed. Install the serve extra: "
+            "`uv run --package pymcap-cli --extra serve pymcap-cli index serve` "
+            "or `pip install 'pymcap-cli[serve]'`."
+        )
+        return 1
+
+    if not _validate_db_readable(db_path):
+        return 1
+
+    with ExitStack() as stack:
+        # Datasette names a DB by its filename stem; serve through a stable
+        # `index.sqlite` path so the metadata/template `/index/...` links
+        # resolve regardless of the real --db filename.
+        tmp = Path(stack.enter_context(tempfile.TemporaryDirectory()))
+        db_link = tmp / "index.sqlite"
+        _create_stable_db_link(db_path, db_link)
+
+        assets = stack.enter_context(
+            importlib.resources.as_file(
+                importlib.resources.files("pymcap_cli.index").joinpath("datasette")
+            )
+        )
+        argv = _build_datasette_argv(
+            db_link,
+            assets / "metadata.yaml",
+            assets / "plugins",
+            assets / "templates",
+            host,
+            port,
+            open_browser=not no_browser,
+        )
+
+        url = f"http://{host}:{port}/"
+        ERR.print(f"Serving index [cyan]{db_path}[/] on [link={url}]{url}[/link]")
+        ERR.print("Press Ctrl-C to stop.")
+        try:
+            # argv is sys.executable + fixed args + resolved paths, run without a shell.
+            return subprocess.run(argv, check=False).returncode  # noqa: S603
+        except KeyboardInterrupt:
+            ERR.print("Stopping.")
+            return 0

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/src/pymcap_cli/cmd/roscompress_cmd.py

@@ -23,9 +23,9 @@ from mcap_codec_support.video import (
     FOXGLOVE_COMPRESSED_VIDEO,
     IMAGE_SCHEMAS,
     RAW_SCHEMAS,
+    AnyVideoBackend,
     EncoderConfig,
     EncoderMode,
-    VideoCompressionBackend,
     VideoEncoderError,
     calculate_downscale_dimensions,
     create_video_compression_backend,
@@ -540,7 +540,7 @@ def _handle_pointcloud(
 
 def _handle_raw_to_jpeg(
     msg: DecodedMessage,
-    backend: VideoCompressionBackend,
+    backend: AnyVideoBackend,
     decode_future: Future[Any] | None,
     encoders: dict[str, Any],
     jpeg_quality: int,
@@ -610,7 +610,7 @@ def _handle_raw_to_jpeg(
 
 def _run_compress_loop(
     messages: Iterator[tuple[DecodedMessage, Future[Any] | None]],
-    backend: VideoCompressionBackend,
+    backend: AnyVideoBackend,
     do_video: bool,
     do_jpeg: bool,
     jpeg_quality: int,

{pymcap_cli-0.13.0 → pymcap_cli-0.14.0}/src/pymcap_cli/cmd/split_cmd.py

@@ -2,7 +2,7 @@
 
 import logging
 from pathlib import Path
-from typing import Annotated
+from typing import TYPE_CHECKING, Annotated
 
 from cyclopts import Group, Parameter, validators
 from rich.console import Console
@@ -27,6 +27,9 @@ from pymcap_cli.types.types_manual import (
 )
 from pymcap_cli.utils import bytes_to_human, parse_time_arg
 
+if TYPE_CHECKING:
+    from pymcap_cli.core.processors.base import OutputRouter
+
 logger = logging.getLogger(__name__)
 console = Console()
 
@@ -266,7 +269,7 @@ def split(
                 return 1
 
     # Build split processors
-    processors = []
+    processors: list[OutputRouter] = []
     if duration:
         try:
             duration_ns = parse_duration_ns(duration)