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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymcap-cli
-Version: 0.14.0
+Version: 0.16.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
@@ -37,6 +37,7 @@ Requires-Dist: pymcap-cli[image,draco,bridge,xxhash] ; extra == 'lite'
 Requires-Dist: pyarrow>=15.0.0 ; extra == 'parquet'
 Requires-Dist: numpy>=1.24.0 ; extra == 'parquet'
 Requires-Dist: mcap-codec-support[pointcloud] ; extra == 'parquet'
+Requires-Dist: kaleido>=1.0.0 ; extra == 'plot'
 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'

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

@@ -1,6 +1,6 @@
 [project]
 name = "pymcap-cli"
-version = "0.14.0"
+version = "0.16.0"
 description = "High-performance Python CLI for MCAP file processing with advanced recovery, filtering, and optimization capabilities"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -52,7 +52,10 @@ bridge = ["robo-ws-bridge"]
 draco = ["mcap-codec-support[draco]"]
 image = ["pillow>=10.0"]
 parquet = ["pyarrow>=15.0.0", "numpy>=1.24.0", "mcap-codec-support[pointcloud]"]
-plot = ["plotly>=6.0.0"]
+plot = [
+    "kaleido>=1.0.0",
+    "plotly>=6.0.0",
+]
 pointcloud = ["mcap-codec-support[pointcloud]"]
 video = ["mcap-codec-support[video]"]
 xxhash = ["xxhash>=3.0.0"]

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

@@ -19,6 +19,7 @@ from pymcap_cli.core.mcap_processor import (
     ProcessingOptions,
     ProcessingStats,
 )
+from pymcap_cli.core.rosbag2_layout import expand_bag_paths
 from pymcap_cli.utils import confirm_output_overwrite, read_info
 
 logger = logging.getLogger(__name__)
@@ -64,6 +65,7 @@ def run_processor(
 
     Raises any exception from McapProcessor.process() to the caller.
     """
+    files = expand_bag_paths(files)
     with contextlib.ExitStack() as stack:
         input_files: list[InputFile] = []
 
@@ -98,6 +100,76 @@ def validate_mcap_output(path: Path) -> bool:
     return True
 
 
+def mcap_message_count(path: Path) -> int | None:
+    """Return the message count from an MCAP summary, or None if it can't be read."""
+    try:
+        with path.open("rb") as f:
+            info = read_info(f)
+    except (McapError, InvalidMagicError, OSError, AssertionError) as e:
+        logger.debug(f"Could not read message count for {path}: {e}")
+        return None
+    if info.summary.statistics is None:
+        return None
+    return info.summary.statistics.message_count
+
+
+def _outputs_dropped_all_messages(sources: list[str], outputs: list[Path]) -> bool:
+    """True if every output has zero messages while some local source had messages.
+
+    Guards against deleting sources when a transform silently produced empty output
+    (e.g. the source was truncated before being read). Partial drops — dedup, time or
+    channel filters — are intentionally not flagged; only total loss is.
+    """
+    out_total = 0
+    for p in outputs:
+        count = mcap_message_count(p)
+        if count is None:
+            return False  # unknown — validation already passed, don't second-guess it
+        out_total += count
+    if out_total > 0:
+        return False
+    for src in sources:
+        if urlparse(src).scheme in ("http", "https"):
+            continue  # URLs are never deleted, so their counts don't matter
+        count = mcap_message_count(Path(src))
+        if count:
+            return True
+    return False
+
+
+def _outputs_lost_messages(sources: list[str], outputs: list[Path]) -> bool:
+    """True if the outputs hold fewer messages in total than the local sources.
+
+    For lossless transforms (compress) every source message must appear in the
+    output, so any shortfall means data was dropped. Counts that can't be read
+    are treated as unknown and never trigger a block.
+    """
+    out_total = 0
+    for p in outputs:
+        count = mcap_message_count(p)
+        if count is None:
+            return False
+        out_total += count
+    src_total = 0
+    for src in sources:
+        if urlparse(src).scheme in ("http", "https"):
+            continue
+        count = mcap_message_count(Path(src))
+        if count is None:
+            return False
+        src_total += count
+    return out_total < src_total
+
+
+def processing_had_errors(stats: ProcessingStats) -> bool:
+    """True if the processor swallowed read/validation errors during the run.
+
+    Such a run produces incomplete output even when it exits cleanly, so it is
+    not safe to delete or replace the source from it.
+    """
+    return stats.errors_encountered > 0 or stats.validation_errors > 0
+
+
 def delete_source_files(sources: list[str], outputs: list[Path]) -> None:
     """Delete each local source file. Skip URLs and any source path that
     resolves to one of ``outputs`` (with a warning).
@@ -134,14 +206,19 @@ def in_place_temp_path(source: Path) -> Path:
 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).
+    Returns 0 on success and 1 if the temp output failed validation or is empty
+    while the source had messages. In those cases the 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
+    if _outputs_lost_messages([str(source)], [tmp_output]):
+        logger.error("Output has fewer messages than the source — source file preserved.")
+        tmp_output.unlink(missing_ok=True)
+        return 1
     tmp_output.replace(source)
     logger.info(f"Replaced source: {source}")
     return 0
@@ -151,17 +228,33 @@ def finalize_delete_source(
     *,
     sources: list[str],
     outputs: list[Path],
+    require_lossless: bool = False,
 ) -> int:
     """Validate every output and, if all valid, delete the eligible sources.
 
-    Returns 0 on success (sources deleted or skipped with warning) and 1 if
-    any output failed validation (no sources are deleted in that case).
+    Returns 0 on success (sources deleted or skipped with warning) and 1 if there
+    are no outputs, any output failed validation, or every output is empty while a
+    source had messages. No sources are deleted in those cases.
+
+    When ``require_lossless`` is set (transforms that must preserve every message,
+    e.g. ``compress``), any shortfall in total output messages versus the sources
+    also preserves them — not just total loss.
     """
+    if not outputs:
+        logger.error("No output files were produced — source file(s) preserved.")
+        return 1
     invalid = [p for p in outputs if not validate_mcap_output(p)]
     if invalid:
         for p in invalid:
             logger.error(f"[red]Output failed validation: {p}[/red]")
         logger.error("Source file(s) preserved — output not safe to replace source.")
         return 1
+    if require_lossless:
+        if _outputs_lost_messages(sources, outputs):
+            logger.error("Output has fewer messages than the source(s) — source file(s) preserved.")
+            return 1
+    elif _outputs_dropped_all_messages(sources, outputs):
+        logger.error("Output contains no messages but the source did — source file(s) preserved.")
+        return 1
     delete_source_files(sources, outputs)
     return 0

{pymcap_cli-0.14.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/_run_processor_multi.py

@@ -11,6 +11,7 @@ from pymcap_cli.core.mcap_processor import (
     OutputOptions,
     ProcessingOptions,
 )
+from pymcap_cli.core.rosbag2_layout import expand_bag_paths
 
 
 def run_processor_multi(
@@ -28,6 +29,9 @@ def run_processor_multi(
     """
     if input_options is None:
         input_options = InputOptions.from_args()
+    files = expand_bag_paths(files)
+    # Let the OutputManager refuse to open a segment that would truncate an input.
+    output_options.input_paths = tuple(files)
     with contextlib.ExitStack() as stack:
         input_files: list[InputFile] = []
 

{pymcap_cli-0.14.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/compress_cmd.py

@@ -10,6 +10,7 @@ from pymcap_cli.cmd._run_processor import (
     finalize_delete_source,
     finalize_replace_source,
     in_place_temp_path,
+    processing_had_errors,
     resolve_overwrite_policy,
     run_processor,
 )
@@ -30,6 +31,7 @@ from pymcap_cli.types.types_manual import (
     NoClobberOption,
     OutputPathOption,
 )
+from pymcap_cli.utils import output_overwrites_input
 
 logger = logging.getLogger(__name__)
 console = Console()
@@ -113,6 +115,12 @@ def compress(
         if output is None:
             logger.error("Either --output or --in-place is required.")
             return 1
+        if output_overwrites_input(file, output):
+            logger.error(
+                "Output path is the same file as the input. "
+                "Use --in-place to compress in place safely."
+            )
+            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.")
@@ -139,14 +147,22 @@ def compress(
         console.print(result.stats)
     except Exception:
         logger.exception("Error during compression")
-        if in_place:
-            output.unlink(missing_ok=True)
+        # The output was opened "wb" (truncated) before processing, so a failed run
+        # leaves an empty/partial file. Remove it rather than leaving a 0-byte result.
+        output.unlink(missing_ok=True)
         return 1
 
     if in_place:
+        if processing_had_errors(result.stats):
+            logger.error("Processing reported errors — source preserved, not replaced in place.")
+            output.unlink(missing_ok=True)
+            return 1
         return finalize_replace_source(source=Path(file), tmp_output=output)
 
     if delete_source:
-        return finalize_delete_source(sources=[file], outputs=[output])
+        if processing_had_errors(result.stats):
+            logger.error("Processing reported errors — source file preserved.")
+            return 1
+        return finalize_delete_source(sources=[file], outputs=[output], require_lossless=True)
 
     return 0

{pymcap_cli-0.14.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/info_cmd.py

@@ -10,6 +10,7 @@ from datetime import datetime, timedelta, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Annotated
+from urllib.parse import urlparse
 
 from cyclopts import Group as CycloptsGroup
 from cyclopts import Parameter
@@ -17,12 +18,13 @@ from rich.console import Console, Group, RenderableType
 from rich.live import Live
 from rich.table import Table
 from rich.text import Text
-from small_mcap import McapError, rebuild_summary
+from small_mcap import McapError, RebuildInfo, rebuild_summary
 from small_mcap.records import Summary
 
 from pymcap_cli.constants import NS_TO_MS, NS_TO_SEC
 from pymcap_cli.core.input_handler import open_input
 from pymcap_cli.core.qos import parse_qos_profiles
+from pymcap_cli.core.rosbag2_layout import find_bag_splits, read_aggregated_bag_info
 from pymcap_cli.display.display_utils import (
     ChannelTableColumn,
     DistributionBar,
@@ -241,6 +243,41 @@ def _qos_from_summary(summary: Summary) -> dict[int, list[QosProfile]]:
     return out
 
 
+def _is_local_dir(path: str) -> bool:
+    return urlparse(path).scheme not in ("http", "https") and Path(path).is_dir()
+
+
+def _load_info(
+    file: str,
+    *,
+    rebuild: bool,
+    exact_sizes: bool,
+    debug: bool,
+) -> tuple[RebuildInfo, int, str]:
+    """Read info for one ``info`` argument.
+
+    A multi-split rosbag2 directory is aggregated into one logical RebuildInfo;
+    a plain file (or single-split directory) is read directly. Returns
+    ``(info, size, label)`` where ``label`` names the file or bag for display.
+    """
+    if _is_local_dir(file):
+        splits = find_bag_splits(Path(file))
+        if not splits:
+            raise ValueError(f"{file!r} is not an MCAP file or a rosbag2 bag directory")
+        if len(splits) > 1:
+            info_data, total = read_aggregated_bag_info(
+                splits, rebuild=rebuild, exact_sizes=exact_sizes
+            )
+            return info_data, total, file
+        file = str(splits[0])
+
+    with open_input(file, buffering=0, debug=debug) as (f_buffered, file_size):
+        info_data = read_or_rebuild_info(
+            f_buffered, file_size, rebuild=rebuild, exact_sizes=exact_sizes
+        )
+    return info_data, file_size, file
+
+
 def _build_info_display(
     data: McapInfoOutput,
     has_chunk_info: bool,
@@ -454,6 +491,14 @@ def info(
             group=DISPLAY_GROUP,
         ),
     ] = False,
+    qos: Annotated[
+        bool,
+        Parameter(
+            name=["--qos"],
+            negative="--no-qos",
+            group=DISPLAY_GROUP,
+        ),
+    ] = False,
     watch: Annotated[
         bool,
         Parameter(
@@ -490,6 +535,8 @@ def info(
     ----------
     files
         Path(s) to MCAP file(s) to analyze (local files or HTTP/HTTPS URLs).
+        A rosbag2 bag directory (``<bag>/<bag>_<N>.mcap`` splits) may be passed
+        in place of a file; its splits are aggregated into one combined view.
     rebuild
         Rebuild file metadata by scanning all records (use for corrupt or
         summary-less files).
@@ -515,6 +562,9 @@ def info(
         --rebuild to calculate message intervals.
     tree
         Display channels in a hierarchical tree structure based on topic paths.
+    qos
+        Show the per-channel QoS column for ROS 2 MCAPs (default: off). Pass
+        --qos to show it.
     watch
         Watch the file for changes and display live-updating statistics.
         Requires exactly one local file. Incompatible with --json and --compress.
@@ -582,20 +632,32 @@ def info(
         if len(files) != 1:
             logger.error("--watch requires exactly one file")
             return 1
+        watch_target = files[0]
+        if _is_local_dir(watch_target):
+            splits = find_bag_splits(Path(watch_target))
+            if not splits:
+                logger.error("%r is not an MCAP file or a rosbag2 bag directory", watch_target)
+                return 1
+            if len(splits) > 1:
+                logger.error(
+                    "--watch does not support multi-split rosbag2 directories; "
+                    "pass a single .mcap file"
+                )
+                return 1
+            watch_target = str(splits[0])
         return _watch_file(
-            files[0], sort.value, reverse, index_duration, median, tree, watch_interval
+            watch_target, sort.value, reverse, index_duration, median, tree, watch_interval
         )
 
     # Link output mode
     if link:
         mode: ScanMode = "exact" if exact_sizes else ("rebuild" if rebuild else "summary")
         for file in files:
-            with open_input(file, buffering=0, debug=debug) as (f_buffered, file_size):
-                info_data = read_or_rebuild_info(
-                    f_buffered, file_size, rebuild=rebuild, exact_sizes=exact_sizes
-                )
-            data = info_to_dict(info_data, str(file), file_size)
-            url = generate_link(data, str(file), file_size, mode)
+            info_data, file_size, label = _load_info(
+                file, rebuild=rebuild, exact_sizes=exact_sizes, debug=debug
+            )
+            data = info_to_dict(info_data, label, file_size)
+            url = generate_link(data, label, file_size, mode)
             print(url)  # noqa: T201
         return 0
 
@@ -603,11 +665,10 @@ def info(
     if json_output:
         all_outputs: list[McapInfoOutput] = []
         for file in files:
-            with open_input(file, buffering=0, debug=debug) as (f_buffered, file_size):
-                info_data = read_or_rebuild_info(
-                    f_buffered, file_size, rebuild=rebuild, exact_sizes=exact_sizes
-                )
-            data = info_to_dict(info_data, str(file), file_size)
+            info_data, file_size, label = _load_info(
+                file, rebuild=rebuild, exact_sizes=exact_sizes, debug=debug
+            )
+            data = info_to_dict(info_data, label, file_size)
             all_outputs.append(data)
         _output_json(all_outputs, compress)
         return 0
@@ -617,13 +678,12 @@ def info(
         if i > 0:
             console.print("\n" + "=" * 80 + "\n")
 
-        with open_input(file, buffering=0, debug=debug) as (f_buffered, file_size):
-            info_data = read_or_rebuild_info(
-                f_buffered, file_size, rebuild=rebuild, exact_sizes=exact_sizes
-            )
+        info_data, file_size, label = _load_info(
+            file, rebuild=rebuild, exact_sizes=exact_sizes, debug=debug
+        )
 
         # Get structured data
-        data = info_to_dict(info_data, str(file), file_size)
+        data = info_to_dict(info_data, label, file_size)
         has_chunk_info = info_data.chunk_information is not None
 
         # Warn if sorting by size fields when channel_sizes is unavailable
@@ -658,7 +718,7 @@ def info(
             )
             console.print()
 
-        qos_by_channel_id = _qos_from_summary(info_data.summary)
+        qos_by_channel_id = _qos_from_summary(info_data.summary) if qos else None
 
         # Display all sections
         console.print(
@@ -676,7 +736,7 @@ def info(
 
         # Show shareable web inspector link
         mode: ScanMode = "exact" if exact_sizes else ("rebuild" if rebuild else "summary")
-        url = generate_link(data, str(file), file_size, mode)
+        url = generate_link(data, label, file_size, mode)
         console.print(f"\n[link={url}][dim]View in web inspector[/dim][/]")
 
     return 0

{pymcap_cli-0.14.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/merge_cmd.py

@@ -8,6 +8,7 @@ from rich.console import Console
 
 from pymcap_cli.cmd._run_processor import (
     finalize_delete_source,
+    processing_had_errors,
     resolve_overwrite_policy,
     run_processor,
 )
@@ -18,6 +19,7 @@ from pymcap_cli.core.mcap_processor import (
 )
 from pymcap_cli.core.processors.base import InputProcessor  # noqa: TC001 - runtime annotation below
 from pymcap_cli.core.processors.dedup import DedupIdenticalProcessor
+from pymcap_cli.core.rosbag2_layout import expand_bag_paths
 from pymcap_cli.types.types_manual import (
     ChunkSizeOption,
     CompressionOption,
@@ -29,6 +31,7 @@ from pymcap_cli.types.types_manual import (
 from pymcap_cli.utils import (
     AttachmentsMode,
     MetadataMode,
+    output_overwrites_input,
 )
 
 logger = logging.getLogger(__name__)
@@ -109,6 +112,7 @@ def merge(
     pymcap-cli merge *.mcap -o all_recordings.mcap --compression lz4
     ```
     """
+    files = expand_bag_paths(files)
     if len(files) < 2:
         logger.error("At least 2 input files are required for merging")
         return 1
@@ -118,6 +122,10 @@ def merge(
         logger.error("--force and --no-clobber cannot be used together.")
         return 1
 
+    if any(output_overwrites_input(f, output) for f in files):
+        logger.error("Output path is the same file as an input; choose a different output file.")
+        return 1
+
     dedup_processor = DedupIdenticalProcessor() if dedup_identical else None
     extra_processors: list[InputProcessor] | None = [dedup_processor] if dedup_processor else None
 
@@ -147,6 +155,9 @@ def merge(
         return 1
 
     if delete_source:
+        if processing_had_errors(result.stats):
+            logger.error("Processing reported errors — source file(s) preserved.")
+            return 1
         return finalize_delete_source(sources=list(files), outputs=[output])
 
     return 0

{pymcap_cli-0.14.0 → pymcap_cli-0.16.0}/src/pymcap_cli/cmd/plot_cmd.py

@@ -65,7 +65,12 @@ def plot(
 
     Extracts values along message paths and plots them over time using plotly.
     Supports numeric, boolean, and string values natively. Multiple paths can
-    be overlaid.
+    be overlaid. Array-valued paths expand into one trace per element index.
+
+    Output format is chosen from the ``-o`` suffix: ``.html`` (interactive) or
+    ``.png`` / ``.svg`` / ``.pdf`` / ``.jpg`` / ``.webp`` (static image, no
+    browser needed — handy over SSH). With no ``-o`` the figure opens in a
+    browser.
 
     Paths can be given a custom label: "Label=/topic.field"
 
@@ -75,6 +80,7 @@ def plot(
       pymcap-cli plot recording.mcap --xy /odom.pose.position.x /odom.pose.position.y
       pymcap-cli plot recording.mcap /odom.pose.position.x -d 1000
       pymcap-cli plot recording.mcap /odom.pose.position.x -s 10 -e 20 -o plot.html
+      pymcap-cli plot recording.mcap "/joints.position[:].@degrees" -o joints.svg
     """
     if not paths:
         logger.error("At least one message path is required")
@@ -93,6 +99,7 @@ def plot(
             downsample=downsample,
             xy=xy,
             force=force,
+            source_name=Path(file).name,
         )
     except (ValueError, ValidationError) as exc:
         logger.error(str(exc))  # noqa: TRY400

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

@@ -1,5 +1,6 @@
 """Command to compress image and point cloud topics in MCAP files."""
 
+import contextlib
 import logging
 from collections import deque
 from collections.abc import Iterable, Iterator
@@ -50,7 +51,7 @@ from pymcap_cli.core.mcap_transform import (
 )
 from pymcap_cli.exporters._common import normalize_schema_name
 from pymcap_cli.types.types_manual import ForceOverwriteOption, OutputPathOption
-from pymcap_cli.utils import confirm_output_overwrite
+from pymcap_cli.utils import confirm_output_overwrite, output_overwrites_input
 
 logger = logging.getLogger(__name__)
 console = Console()
@@ -246,6 +247,10 @@ def roscompress(
     pointcloud
         Enable point cloud compression. Default: True.
     """
+    if output_overwrites_input(file, output):
+        logger.error("Output path is the same file as the input; choose a different output file.")
+        return 1
+
     confirm_output_overwrite(output, force)
 
     if not 1 <= jpeg_quality <= 100:
@@ -332,11 +337,20 @@ def roscompress(
     last_video_times: dict[str, tuple[int, int]] = {}
     pending_messages: dict[str, deque[DecodedMessage]] = {}
 
-    with (
-        open_input(file) as (input_stream, input_size),
-        output.open("wb") as output_stream,
-        create_progress(title="Compressing images") as progress,
-    ):
+    with contextlib.ExitStack() as stack:
+        # Opening the output truncates it; remove the truncated/partial file if the
+        # run does not finish cleanly. Registered first so it runs after the stream
+        # is closed on exit.
+        ok = False
+
+        def _cleanup_on_failure() -> None:
+            if not ok:
+                output.unlink(missing_ok=True)
+
+        stack.callback(_cleanup_on_failure)
+        input_stream, input_size = stack.enter_context(open_input(file))
+        output_stream = stack.enter_context(output.open("wb"))
+        progress = stack.enter_context(create_progress(title="Compressing images"))
         task_id = progress.add_task("Processing messages", total=total_message_count)
 
         writer = McapWriter(
@@ -411,6 +425,7 @@ def roscompress(
                         counters["converted"] += 1
 
         writer.finish()
+        ok = compress_ok
 
     if not compress_ok:
         return 1

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

@@ -8,7 +8,11 @@ from cyclopts import Group, Parameter, validators
 from rich.console import Console
 from ros_parser.message_path import MessagePathError
 
-from pymcap_cli.cmd._run_processor import finalize_delete_source, resolve_overwrite_policy
+from pymcap_cli.cmd._run_processor import (
+    finalize_delete_source,
+    processing_had_errors,
+    resolve_overwrite_policy,
+)
 from pymcap_cli.cmd._run_processor_multi import run_processor_multi
 from pymcap_cli.constants import DEFAULT_CHUNK_SIZE, DEFAULT_COMPRESSION
 from pymcap_cli.core.mcap_processor import InputOptions, OutputOptions
@@ -394,6 +398,9 @@ def split(
         )
 
     if delete_source:
+        if processing_had_errors(result.stats):
+            logger.error("Processing reported errors — source file preserved.")
+            return 1
         outputs = [
             Path(segment.path) for segment in result.processor.output_manager.segments.values()
         ]

{pymcap_cli-0.14.0 → pymcap_cli-0.16.0}/src/pymcap_cli/core/input_handler.py

@@ -11,8 +11,35 @@ from pymcap_cli.debug_wrapper import DebugStreamWrapper
 from pymcap_cli.http_utils import open_http_stream
 
 
+def resolve_mcap_path(path: str) -> str:
+    """Resolve a rosbag2 bag directory to its single ``.mcap`` file.
+
+    rosbag2 lays a recording out as ``<bagname>/<bagname>_<N>.mcap`` splits.
+    For single-file commands this resolves a directory holding exactly one split
+    to that file. A multi-split directory (which has no single-file meaning here)
+    or a directory with no resolvable MCAP raises ``ValueError`` rather than
+    surfacing an opaque ``IsADirectoryError`` downstream. Files and URLs pass
+    through unchanged.
+    """
+    candidate_dir = Path(path)
+    if not candidate_dir.is_dir():
+        return path
+
+    from pymcap_cli.core.rosbag2_layout import find_bag_splits  # noqa: PLC0415
+
+    splits = find_bag_splits(candidate_dir)
+    if len(splits) == 1:
+        return str(splits[0])
+    if not splits:
+        raise ValueError(f"{path!r} is not an MCAP file or a rosbag2 bag directory")
+    raise ValueError(
+        f"{path!r} is a multi-split rosbag2 directory ({len(splits)} files); "
+        f"this command reads a single file — use 'info' or 'merge'"
+    )
+
+
 def _open_path_file(url: ParseResult) -> tuple[io.RawIOBase, int]:
-    file_path = Path(url.path)
+    file_path = Path(resolve_mcap_path(url.path))
     raw_stream = file_path.open("rb", buffering=0)
     size = file_path.stat().st_size
     return raw_stream, size