pymcap-cli 0.4.0__tar.gz → 0.6.0__tar.gz

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymcap-cli
-Version: 0.4.0
+Version: 0.6.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
@@ -26,6 +26,7 @@ Requires-Dist: mcap-ros2-support-fast
 Requires-Dist: cyclopts>=4
 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] ; extra == 'all'
 Requires-Dist: plotly>=6.0.0 ; extra == 'plot'
@@ -133,6 +134,13 @@ pymcap-cli cat recording.mcap --query '/detections.objects[:]{confidence>0.8}'
 
 # Pipe to file as JSONL
 pymcap-cli cat recording.mcap > messages.jsonl
+
+# Write to file with progress bar
+pymcap-cli cat recording.mcap -o messages.jsonl
+
+# Control binary field serialization
+pymcap-cli cat recording.mcap --bytes base64   # base64-encoded
+pymcap-cli cat recording.mcap --bytes skip     # omit binary fields
 ```
 
 ### `tftree` — TF Transform Tree
@@ -153,6 +161,45 @@ pymcap-cli tftree data.mcap
 pymcap-cli tftree data.mcap --static-only
 ```
 
+### `diag` — ROS2 Diagnostics
+
+Inspect ROS2 diagnostics with per-component health overview, sparkline timelines, frequency stats, and time-in-state tracking.
+
+```bash
+# Show components with issues (WARN/ERROR/STALE)
+pymcap-cli diag recording.mcap
+
+# Show all components including OK
+pymcap-cli diag recording.mcap --all
+
+# Detailed inspection of specific components
+pymcap-cli diag recording.mcap --inspect "encoder"
+
+# Hierarchical tree view
+pymcap-cli diag recording.mcap --tree
+
+# JSON output for scripting
+pymcap-cli diag recording.mcap --json
+```
+
+### `plot` — Time-Series Visualization
+
+Plot message fields over time using Plotly. Supports named labels, LTTB downsampling, XY trajectory mode, and saves to interactive HTML. Requires the `plot` extra (`uv add pymcap-cli[plot]`).
+
+```bash
+# Plot a single field
+pymcap-cli plot recording.mcap /odom.pose.position.x
+
+# Named series
+pymcap-cli plot recording.mcap "Vel X=/odom.twist.twist.linear.x"
+
+# XY trajectory plot
+pymcap-cli plot recording.mcap --xy /odom.pose.position.x /odom.pose.position.y
+
+# Downsample to 1000 points and save to file
+pymcap-cli plot recording.mcap /odom.pose.position.x -d 1000 -o plot.html
+```
+
 ### `process` — Unified Processing
 
 The most powerful command — combines recovery, filtering, and optimization in a single pass.
@@ -315,6 +362,21 @@ pymcap-cli roscompress data.mcap -o compressed.mcap
 pymcap-cli roscompress data.mcap -o compressed.mcap --quality 28 --codec h265
 ```
 
+### `rosdecompress` — ROS Decompression
+
+Decompress CompressedVideo and CompressedPointCloud2 topics back to standard ROS formats. Requires the `video` extra.
+
+```bash
+# Decompress to CompressedImage (JPEG)
+pymcap-cli rosdecompress input.mcap output.mcap
+
+# Decompress to raw Image
+pymcap-cli rosdecompress input.mcap output.mcap --video-format raw
+
+# Skip point cloud decompression
+pymcap-cli rosdecompress input.mcap output.mcap --no-pointcloud
+```
+
 ### Shell Autocompletion
 
 ```bash

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/README.md

@@ -89,6 +89,13 @@ pymcap-cli cat recording.mcap --query '/detections.objects[:]{confidence>0.8}'
 
 # Pipe to file as JSONL
 pymcap-cli cat recording.mcap > messages.jsonl
+
+# Write to file with progress bar
+pymcap-cli cat recording.mcap -o messages.jsonl
+
+# Control binary field serialization
+pymcap-cli cat recording.mcap --bytes base64   # base64-encoded
+pymcap-cli cat recording.mcap --bytes skip     # omit binary fields
 ```
 
 ### `tftree` — TF Transform Tree
@@ -109,6 +116,45 @@ pymcap-cli tftree data.mcap
 pymcap-cli tftree data.mcap --static-only
 ```
 
+### `diag` — ROS2 Diagnostics
+
+Inspect ROS2 diagnostics with per-component health overview, sparkline timelines, frequency stats, and time-in-state tracking.
+
+```bash
+# Show components with issues (WARN/ERROR/STALE)
+pymcap-cli diag recording.mcap
+
+# Show all components including OK
+pymcap-cli diag recording.mcap --all
+
+# Detailed inspection of specific components
+pymcap-cli diag recording.mcap --inspect "encoder"
+
+# Hierarchical tree view
+pymcap-cli diag recording.mcap --tree
+
+# JSON output for scripting
+pymcap-cli diag recording.mcap --json
+```
+
+### `plot` — Time-Series Visualization
+
+Plot message fields over time using Plotly. Supports named labels, LTTB downsampling, XY trajectory mode, and saves to interactive HTML. Requires the `plot` extra (`uv add pymcap-cli[plot]`).
+
+```bash
+# Plot a single field
+pymcap-cli plot recording.mcap /odom.pose.position.x
+
+# Named series
+pymcap-cli plot recording.mcap "Vel X=/odom.twist.twist.linear.x"
+
+# XY trajectory plot
+pymcap-cli plot recording.mcap --xy /odom.pose.position.x /odom.pose.position.y
+
+# Downsample to 1000 points and save to file
+pymcap-cli plot recording.mcap /odom.pose.position.x -d 1000 -o plot.html
+```
+
 ### `process` — Unified Processing
 
 The most powerful command — combines recovery, filtering, and optimization in a single pass.
@@ -271,6 +317,21 @@ pymcap-cli roscompress data.mcap -o compressed.mcap
 pymcap-cli roscompress data.mcap -o compressed.mcap --quality 28 --codec h265
 ```
 
+### `rosdecompress` — ROS Decompression
+
+Decompress CompressedVideo and CompressedPointCloud2 topics back to standard ROS formats. Requires the `video` extra.
+
+```bash
+# Decompress to CompressedImage (JPEG)
+pymcap-cli rosdecompress input.mcap output.mcap
+
+# Decompress to raw Image
+pymcap-cli rosdecompress input.mcap output.mcap --video-format raw
+
+# Skip point cloud decompression
+pymcap-cli rosdecompress input.mcap output.mcap --no-pointcloud
+```
+
 ### Shell Autocompletion
 
 ```bash

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymcap-cli"
-version = "0.4.0"
+version = "0.6.0"
 description = "High-performance Python CLI for MCAP file processing with advanced recovery, filtering, and optimization capabilities"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,6 +33,7 @@ dependencies = [
     "cyclopts>=4",
     "ros-parser",
     "platformdirs>=4.0.0",
+    "pyyaml>=6.0",
     "typing-extensions>=4.15.0",
 ]
 

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/src/pymcap_cli/cli.py

@@ -5,6 +5,7 @@ import sys
 from cyclopts import App, Group
 
 from pymcap_cli.cmd import (
+    bag2mcap_cmd,
     cat_cmd,
     compress_cmd,
     convert_cmd,
@@ -87,6 +88,27 @@ except ImportError:
         return 1
 
 
+try:
+    from pymcap_cli.cmd.rosdecompress_cmd import rosdecompress
+except ImportError:
+
+    def rosdecompress() -> int:
+        """ROS decompress command is unavailable because the 'av' package is not installed.
+
+        To enable rosdecompress functionality, please install pymcap-cli with the 'video' extra:
+
+            uv add --group video pymcap-cli
+        """
+        print(  # noqa: T201
+            "Error:\n"
+            "ROS decompress command is unavailable because the 'av' package is not installed.\n"
+            "To enable this functionality, please install pymcap-cli with the 'video' extra:\n\n"
+            "    uv add --group video pymcap-cli\n",
+            file=sys.stderr,
+        )
+        return 1
+
+
 app = App(
     name="pymcap-cli",
     help="CLI tool for slicing and dicing MCAP files.",
@@ -109,6 +131,7 @@ app.command(name="tftree", group=inspect_group)(tftree_cmd.tftree)
 app.command(name="topic-chunks", group=inspect_group)(topic_chunks_cmd.topic_chunks)
 
 # Transform commands — convert, filter, or produce new files
+app.command(name="bag2mcap", group=transform_group)(bag2mcap_cmd.bag2mcap)
 app.command(name="compress", group=transform_group)(compress_cmd.compress)
 app.command(name="convert", group=transform_group)(convert_cmd.convert)
 app.command(name="filter", group=transform_group)(filter_cmd.filter_cmd)
@@ -119,6 +142,7 @@ app.command(name="recover", group=transform_group)(recover_cmd.recover)
 app.command(name="recover-inplace", group=transform_group)(recover_inplace_cmd.recover_inplace)
 app.command(name="plot", group=inspect_group)(plot)
 app.command(name="roscompress", group=transform_group)(roscompress)
+app.command(name="rosdecompress", group=transform_group)(rosdecompress)
 app.command(name="video", group=transform_group)(video)
 
 

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/src/pymcap_cli/cmd/_run_processor.py

@@ -4,8 +4,8 @@ import contextlib
 from dataclasses import dataclass
 from pathlib import Path
 
-from pymcap_cli.input_handler import open_input
-from pymcap_cli.mcap_processor import (
+from pymcap_cli.core.input_handler import open_input
+from pymcap_cli.core.mcap_processor import (
     InputFile,
     InputOptions,
     McapProcessor,

pymcap_cli-0.6.0/src/pymcap_cli/cmd/bag2mcap_cmd.py

@@ -0,0 +1,285 @@
+"""Convert ROS1 bag files to MCAP format (ros1 profile)."""
+
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from dataclasses import dataclass
+from pathlib import Path
+from typing import BinaryIO
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+    TimeRemainingColumn,
+)
+from small_mcap.writer import CompressionType, McapWriter
+from small_mcap.writer import CompressionType as WriterCompressionType
+
+from pymcap_cli.display.osc_utils import OSCProgressColumn
+from pymcap_cli.types.types_manual import (
+    DEFAULT_CHUNK_SIZE,
+    DEFAULT_COMPRESSION,
+    ChunkSizeOption,
+    CompressionOption,
+    ForceOverwriteOption,
+    OutputPathOption,
+)
+from pymcap_cli.utils import confirm_output_overwrite
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Bag2McapOptions:
+    """Options for bag to MCAP conversion."""
+
+    chunk_size: int = 1024 * 1024 * 8  # 8MB default
+    compression: CompressionType = CompressionType.ZSTD
+    enable_crcs: bool = True
+    use_chunking: bool = True
+
+
+@dataclass
+class Bag2McapStatistics:
+    """Statistics from bag to MCAP conversion."""
+
+    topic_count: int
+    message_count: int
+    schema_count: int
+
+
+def convert_bag_to_mcap(
+    bag_path: Path,
+    output: BinaryIO,
+    options: Bag2McapOptions,
+) -> Bag2McapStatistics:
+    """Convert a ROS1 bag file to MCAP format with ros1 profile.
+
+    Messages are passed through as raw ROS1-serialized bytes.
+    Schema encoding is "ros1msg", message encoding is "ros1".
+
+    Args:
+        bag_path: Path to the input .bag file.
+        output: Output stream for MCAP data.
+        options: Conversion options.
+
+    Returns:
+        Conversion statistics.
+
+    """
+    from pymcap_cli.rosbag_reader import read_bag_info, read_bag_messages  # noqa: PLC0415
+
+    with bag_path.open("rb") as bag_file:
+        info = read_bag_info(bag_file)
+
+    if not info.connections:
+        logger.warning("No connections found in bag file")
+        writer = McapWriter(
+            output,
+            chunk_size=options.chunk_size,
+            compression=options.compression,
+            enable_crcs=options.enable_crcs,
+            use_chunking=options.use_chunking,
+        )
+        writer.start(profile="ros1")
+        writer.finish()
+        return Bag2McapStatistics(topic_count=0, message_count=0, schema_count=0)
+
+    logger.info(f"Found {len(info.connections)} connections, {info.message_count} messages")
+
+    # Build schema map: deduplicate by msg_type
+    schema_map: dict[str, int] = {}  # msg_type -> schema_id
+    schema_definitions: dict[int, tuple[str, str]] = {}  # schema_id -> (msg_type, definition)
+    next_schema_id = 1
+
+    for conn in info.connections.values():
+        if conn.msg_type not in schema_map:
+            schema_id = next_schema_id
+            next_schema_id += 1
+            schema_map[conn.msg_type] = schema_id
+            schema_definitions[schema_id] = (conn.msg_type, conn.message_definition)
+
+    # Build channel map: deduplicate by (topic, msg_type)
+    # Multiple connections can exist for the same topic (multiple publishers)
+    channel_map: dict[tuple[str, str], int] = {}  # (topic, msg_type) -> channel_id
+    conn_to_channel: dict[int, int] = {}  # conn_id -> channel_id
+    next_channel_id = 1
+
+    for conn in info.connections.values():
+        key = (conn.topic, conn.msg_type)
+        if key not in channel_map:
+            channel_map[key] = next_channel_id
+            next_channel_id += 1
+        conn_to_channel[conn.conn_id] = channel_map[key]
+
+    # Create MCAP writer
+    writer = McapWriter(
+        output,
+        chunk_size=options.chunk_size,
+        compression=options.compression,
+        enable_crcs=options.enable_crcs,
+        use_chunking=options.use_chunking,
+    )
+    writer.start(profile="ros1")
+
+    # Write schemas
+    for schema_id, (msg_type, definition) in schema_definitions.items():
+        writer.add_schema(
+            schema_id=schema_id,
+            name=msg_type,
+            encoding="ros1msg",
+            data=definition.encode("utf-8"),
+        )
+
+    # Write channels
+    for (topic, msg_type), channel_id in channel_map.items():
+        schema_id = schema_map[msg_type]
+
+        # Collect metadata from connections for this channel
+        metadata: dict[str, str] = {}
+        for conn in info.connections.values():
+            if conn.topic == topic and conn.msg_type == msg_type:
+                metadata["md5sum"] = conn.md5sum
+                if conn.callerid:
+                    metadata["callerid"] = conn.callerid
+                break
+
+        writer.add_channel(
+            channel_id=channel_id,
+            topic=topic,
+            message_encoding="ros1",
+            schema_id=schema_id,
+            metadata=metadata,
+        )
+
+    # Read and write messages
+    logger.info("Converting messages...")
+    sequence_counters: defaultdict[int, int] = defaultdict(int)
+    message_count = 0
+
+    with (
+        bag_path.open("rb") as bag_file,
+        Progress(
+            SpinnerColumn(),
+            TextColumn("[bold blue]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            TimeRemainingColumn(),
+            OSCProgressColumn(title="Converting messages"),
+            transient=False,
+        ) as progress,
+    ):
+        task = progress.add_task(
+            "[cyan]Converting messages...",
+            total=info.message_count if info.message_count > 0 else None,
+        )
+
+        for msg in read_bag_messages(bag_file, info):
+            channel_id = conn_to_channel[msg.conn_id]
+
+            writer.add_message(
+                channel_id=channel_id,
+                log_time=msg.time_ns,
+                data=msg.data,
+                publish_time=msg.time_ns,
+                sequence=sequence_counters[channel_id],
+            )
+            sequence_counters[channel_id] += 1
+            message_count += 1
+            progress.advance(task)
+
+    writer.finish()
+
+    logger.info(
+        f"Conversion complete: {len(channel_map)} topics, "
+        f"{message_count:,} messages, {len(schema_definitions)} schemas"
+    )
+
+    return Bag2McapStatistics(
+        topic_count=len(channel_map),
+        message_count=message_count,
+        schema_count=len(schema_definitions),
+    )
+
+
+console = Console()
+
+
+def bag2mcap(
+    file: str,
+    output: OutputPathOption,
+    *,
+    chunk_size: ChunkSizeOption = DEFAULT_CHUNK_SIZE,
+    compression: CompressionOption = DEFAULT_COMPRESSION,
+    force: ForceOverwriteOption = False,
+) -> int:
+    """Convert ROS1 bag files to MCAP format.
+
+    Converts ROS1 bag files to MCAP with ros1 profile, preserving all
+    message data as raw ROS1-serialized bytes. Schemas use ros1msg encoding
+    with the full message definition from the bag file.
+
+    Parameters
+    ----------
+    file
+        Path to the ROS1 .bag file to convert.
+    output
+        Output MCAP filename.
+    chunk_size
+        Chunk size of output file in bytes.
+    compression
+        Compression algorithm for output file.
+    force
+        Force overwrite of output file without confirmation.
+
+    Examples
+    --------
+    ```
+    # Basic conversion
+    pymcap-cli bag2mcap recording.bag -o recording.mcap
+
+    # With custom compression
+    pymcap-cli bag2mcap recording.bag -o recording.mcap --compression lz4
+    ```
+    """
+    input_path = Path(file)
+    if not input_path.exists():
+        console.print(f"[red]Error: Input file '{file}' does not exist[/red]")
+        return 1
+
+    confirm_output_overwrite(output, force)
+
+    compression_map = {
+        "zstd": WriterCompressionType.ZSTD,
+        "lz4": WriterCompressionType.LZ4,
+        "none": WriterCompressionType.NONE,
+    }
+    writer_compression = compression_map[compression.value]
+
+    options = Bag2McapOptions(
+        chunk_size=chunk_size,
+        compression=writer_compression,
+    )
+
+    console.print(f"[blue]Converting '{file}' to '{output}'[/blue]")
+
+    with output.open("wb") as output_stream:
+        try:
+            stats = convert_bag_to_mcap(input_path, output_stream, options)
+
+            console.print("[green]Conversion completed successfully[/green]")
+            console.print(
+                f"Converted {stats.topic_count} topics, "
+                f"{stats.message_count:,} messages, "
+                f"{stats.schema_count} schemas"
+            )
+        except Exception as e:  # noqa: BLE001
+            console.print(f"[red]Error during conversion: {e}[/red]")
+            return 1
+
+    return 0

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/src/pymcap_cli/cmd/cat_cmd.py

@@ -25,7 +25,7 @@ from small_mcap import JSONDecoderFactory
 from small_mcap.reader import read_message_decoded
 from small_mcap.records import Channel
 
-from pymcap_cli.input_handler import open_input
+from pymcap_cli.core.input_handler import open_input
 from pymcap_cli.utils import MAX_INT64, ProgressTrackingIO, file_progress, parse_timestamp_args
 
 console_err = Console(stderr=True)

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/src/pymcap_cli/cmd/compress_cmd.py

@@ -3,8 +3,8 @@
 from rich.console import Console
 
 from pymcap_cli.cmd._run_processor import run_processor
-from pymcap_cli.mcap_processor import InputOptions, OutputOptions
-from pymcap_cli.types_manual import (
+from pymcap_cli.core.mcap_processor import InputOptions, OutputOptions
+from pymcap_cli.types.types_manual import (
     DEFAULT_CHUNK_SIZE,
     DEFAULT_COMPRESSION,
     ChunkSizeOption,

{pymcap_cli-0.4.0 → pymcap_cli-0.6.0}/src/pymcap_cli/cmd/convert_cmd.py

@@ -21,9 +21,9 @@ from rich.progress import (
 from small_mcap.writer import CompressionType, McapWriter
 from small_mcap.writer import CompressionType as WriterCompressionType
 
-from pymcap_cli.msg_resolver import ROS2Distro, get_message_definition
-from pymcap_cli.osc_utils import OSCProgressColumn
-from pymcap_cli.types_manual import (
+from pymcap_cli.core.msg_resolver import ROS2Distro, get_message_definition
+from pymcap_cli.display.osc_utils import OSCProgressColumn
+from pymcap_cli.types.types_manual import (
     DEFAULT_CHUNK_SIZE,
     DEFAULT_COMPRESSION,
     ChunkSizeOption,