foxglove-sdk 0.16.2__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

foxglove/tests/test_mcap.py

@@ -0,0 +1,368 @@
+from pathlib import Path
+from typing import Callable, Generator, Optional
+
+import pytest
+from foxglove import Channel, ChannelDescriptor, Context, open_mcap
+from foxglove.mcap import MCAPWriteOptions
+
+chan = Channel("test", schema={"type": "object"})
+
+
+@pytest.fixture
+def make_tmp_mcap(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> Generator[Callable[[], Path], None, None]:
+    mcap: Optional[Path] = None
+    dir: Optional[Path] = None
+
+    def _make_tmp_mcap() -> Path:
+        nonlocal dir, mcap
+        dir = tmp_path_factory.mktemp("test", numbered=True)
+        mcap = dir / "test.mcap"
+        return mcap
+
+    yield _make_tmp_mcap
+
+    if mcap is not None and dir is not None:
+        try:
+            mcap.unlink()
+            dir.rmdir()
+        except FileNotFoundError:
+            pass
+
+
+@pytest.fixture
+def tmp_mcap(make_tmp_mcap: Callable[[], Path]) -> Generator[Path, None, None]:
+    yield make_tmp_mcap()
+
+
+def test_open_with_str(tmp_mcap: Path) -> None:
+    open_mcap(str(tmp_mcap))
+
+
+def test_overwrite(tmp_mcap: Path) -> None:
+    tmp_mcap.touch()
+    with pytest.raises(FileExistsError):
+        open_mcap(tmp_mcap)
+    open_mcap(tmp_mcap, allow_overwrite=True)
+
+
+def test_explicit_close(tmp_mcap: Path) -> None:
+    mcap = open_mcap(tmp_mcap)
+    for ii in range(20):
+        chan.log({"foo": ii})
+    size_before_close = tmp_mcap.stat().st_size
+    mcap.close()
+    assert tmp_mcap.stat().st_size > size_before_close
+
+
+def test_context_manager(tmp_mcap: Path) -> None:
+    with open_mcap(tmp_mcap):
+        for ii in range(20):
+            chan.log({"foo": ii})
+        size_before_close = tmp_mcap.stat().st_size
+    assert tmp_mcap.stat().st_size > size_before_close
+
+
+def test_writer_compression(make_tmp_mcap: Callable[[], Path]) -> None:
+    tmp_1 = make_tmp_mcap()
+    tmp_2 = make_tmp_mcap()
+
+    # Compression is enabled by default
+    mcap_1 = open_mcap(tmp_1)
+    mcap_2 = open_mcap(tmp_2, writer_options=MCAPWriteOptions(compression=None))
+
+    for _ in range(20):
+        chan.log({"foo": "bar"})
+
+    mcap_1.close()
+    mcap_2.close()
+
+    assert tmp_1.stat().st_size < tmp_2.stat().st_size
+
+
+def test_writer_custom_profile(tmp_mcap: Path) -> None:
+    options = MCAPWriteOptions(profile="--custom-profile-1--")
+    with open_mcap(tmp_mcap, writer_options=options):
+        chan.log({"foo": "bar"})
+
+    contents = tmp_mcap.read_bytes()
+    assert contents.find(b"--custom-profile-1--") > -1
+
+
+def test_write_to_different_contexts(make_tmp_mcap: Callable[[], Path]) -> None:
+    tmp_1 = make_tmp_mcap()
+    tmp_2 = make_tmp_mcap()
+
+    ctx1 = Context()
+    ctx2 = Context()
+
+    options = MCAPWriteOptions(compression=None)
+    mcap1 = open_mcap(tmp_1, writer_options=options, context=ctx1)
+    mcap2 = open_mcap(tmp_2, writer_options=options, context=ctx2)
+
+    ch1 = Channel("ctx1", context=ctx1)
+    ch1.log({"a": "b"})
+
+    ch2 = Channel("ctx2", context=ctx2)
+    ch2.log({"has-more-data": "true"})
+
+    mcap1.close()
+    mcap2.close()
+
+    contents1 = tmp_1.read_bytes()
+    contents2 = tmp_2.read_bytes()
+
+    assert len(contents1) < len(contents2)
+
+
+def _verify_metadata_in_file(file_path: Path, expected_metadata: dict) -> None:
+    """Helper function to verify metadata in MCAP file matches expected."""
+    import mcap.reader
+
+    with open(file_path, "rb") as f:
+        reader = mcap.reader.make_reader(f)
+
+        found_metadata = {}
+        metadata_count = 0
+
+        for record in reader.iter_metadata():
+            metadata_count += 1
+            found_metadata[record.name] = dict(record.metadata)
+
+        # Verify count
+        assert metadata_count == len(
+            expected_metadata
+        ), f"Expected {len(expected_metadata)} metadata records, found {metadata_count}"
+
+        # Verify metadata names and content
+        assert set(found_metadata.keys()) == set(
+            expected_metadata.keys()
+        ), "Metadata names don't match"
+
+        for name, expected_kv in expected_metadata.items():
+            assert (
+                found_metadata[name] == expected_kv
+            ), f"Metadata '{name}' has wrong key-value pairs"
+
+
+def _verify_attachments_in_file(
+    file_path: Path, expected_attachments: list[dict]
+) -> None:
+    """Helper function to verify attachments in MCAP file match expected."""
+    import mcap.reader
+
+    with open(file_path, "rb") as f:
+        reader = mcap.reader.make_reader(f)
+
+        found_attachments = []
+        for attachment in reader.iter_attachments():
+            found_attachments.append(
+                {
+                    "log_time": attachment.log_time,
+                    "create_time": attachment.create_time,
+                    "name": attachment.name,
+                    "media_type": attachment.media_type,
+                    "data": attachment.data,
+                }
+            )
+
+        # Verify count
+        assert len(found_attachments) == len(
+            expected_attachments
+        ), f"Expected {len(expected_attachments)} attachments, found {len(found_attachments)}"
+
+        # Verify each attachment matches expected
+        for expected in expected_attachments:
+            matching = [a for a in found_attachments if a["name"] == expected["name"]]
+            assert len(matching) == 1, f"Attachment '{expected['name']}' not found"
+            actual = matching[0]
+            assert (
+                actual["log_time"] == expected["log_time"]
+            ), f"Attachment '{expected['name']}' has wrong log_time"
+            assert (
+                actual["create_time"] == expected["create_time"]
+            ), f"Attachment '{expected['name']}' has wrong create_time"
+            assert (
+                actual["media_type"] == expected["media_type"]
+            ), f"Attachment '{expected['name']}' has wrong media_type"
+            assert (
+                actual["data"] == expected["data"]
+            ), f"Attachment '{expected['name']}' has wrong data"
+
+
+def test_write_metadata(tmp_mcap: Path) -> None:
+    """Test writing metadata to MCAP file."""
+    # Define expected metadata
+    expected_metadata = {
+        "test1": {"key1": "value1", "key2": "value2"},
+        "test2": {"a": "1", "b": "2"},
+        "test3": {"x": "y", "z": "w"},
+    }
+
+    with open_mcap(tmp_mcap) as writer:
+        # This should not raise an error
+        writer.write_metadata("empty", {})
+
+        # Write basic metadata
+        writer.write_metadata("test1", expected_metadata["test1"])
+
+        # Write multiple metadata records
+        writer.write_metadata("test2", expected_metadata["test2"])
+        writer.write_metadata("test3", expected_metadata["test3"])
+
+        # Write empty metadata (should be skipped)
+        writer.write_metadata("empty_test", {})
+
+        # Log some messages
+        for ii in range(5):
+            chan.log({"foo": ii})
+
+    # Verify metadata was written correctly
+    _verify_metadata_in_file(tmp_mcap, expected_metadata)
+
+
+def test_channel_filter(make_tmp_mcap: Callable[[], Path]) -> None:
+    tmp_1 = make_tmp_mcap()
+    tmp_2 = make_tmp_mcap()
+
+    ch1 = Channel("/1", schema={"type": "object"})
+    ch2 = Channel("/2", schema={"type": "object"})
+
+    def filter(ch: ChannelDescriptor) -> bool:
+        return ch.topic.startswith("/1")
+
+    mcap1 = open_mcap(tmp_1, channel_filter=filter)
+    mcap2 = open_mcap(tmp_2, channel_filter=None)
+
+    ch1.log({})
+    ch2.log({})
+
+    mcap1.close()
+    mcap2.close()
+
+    assert tmp_1.stat().st_size < tmp_2.stat().st_size
+
+
+def test_attach_basic(tmp_mcap: Path) -> None:
+    """Test writing a single attachment to MCAP file."""
+    expected_attachments = [
+        {
+            "log_time": 1000000000,
+            "create_time": 2000000000,
+            "name": "config.json",
+            "media_type": "application/json",
+            "data": b'{"setting": true}',
+        }
+    ]
+
+    with open_mcap(tmp_mcap) as writer:
+        writer.attach(
+            log_time=1000000000,
+            create_time=2000000000,
+            name="config.json",
+            media_type="application/json",
+            data=b'{"setting": true}',
+        )
+
+    _verify_attachments_in_file(tmp_mcap, expected_attachments)
+
+
+def test_attach_multiple(tmp_mcap: Path) -> None:
+    """Test writing multiple attachments to MCAP file."""
+    expected_attachments = [
+        {
+            "log_time": 100,
+            "create_time": 200,
+            "name": "config.json",
+            "media_type": "application/json",
+            "data": b'{"setting": true}',
+        },
+        {
+            "log_time": 300,
+            "create_time": 400,
+            "name": "calibration.yaml",
+            "media_type": "text/yaml",
+            "data": b"camera:\n  fx: 500\n  fy: 500",
+        },
+        {
+            "log_time": 500,
+            "create_time": 600,
+            "name": "image.png",
+            "media_type": "image/png",
+            "data": bytes([0x89, 0x50, 0x4E, 0x47]),  # PNG magic bytes
+        },
+    ]
+
+    with open_mcap(tmp_mcap) as writer:
+        writer.attach(
+            log_time=100,
+            create_time=200,
+            name="config.json",
+            media_type="application/json",
+            data=b'{"setting": true}',
+        )
+        writer.attach(
+            log_time=300,
+            create_time=400,
+            name="calibration.yaml",
+            media_type="text/yaml",
+            data=b"camera:\n  fx: 500\n  fy: 500",
+        )
+        writer.attach(
+            log_time=500,
+            create_time=600,
+            name="image.png",
+            media_type="image/png",
+            data=bytes([0x89, 0x50, 0x4E, 0x47]),  # PNG magic bytes
+        )
+
+    _verify_attachments_in_file(tmp_mcap, expected_attachments)
+
+
+def test_attach_with_messages(tmp_mcap: Path) -> None:
+    """Test writing attachments alongside messages."""
+    with open_mcap(tmp_mcap) as writer:
+        # Write some messages
+        for ii in range(5):
+            chan.log({"foo": ii})
+
+        # Write an attachment
+        writer.attach(
+            log_time=1000,
+            create_time=2000,
+            name="notes.txt",
+            media_type="text/plain",
+            data=b"Recording notes",
+        )
+
+        # Write more messages
+        for ii in range(5, 10):
+            chan.log({"foo": ii})
+
+    # Verify attachment was written
+    expected_attachments = [
+        {
+            "log_time": 1000,
+            "create_time": 2000,
+            "name": "notes.txt",
+            "media_type": "text/plain",
+            "data": b"Recording notes",
+        }
+    ]
+    _verify_attachments_in_file(tmp_mcap, expected_attachments)
+
+
+def test_attach_after_close(tmp_mcap: Path) -> None:
+    """Test that attaching after close raises an error."""
+    writer = open_mcap(tmp_mcap)
+    writer.close()
+
+    with pytest.raises(Exception):  # FoxgloveError for SinkClosed
+        writer.attach(
+            log_time=100,
+            create_time=200,
+            name="test.txt",
+            media_type="text/plain",
+            data=b"test",
+        )

foxglove/tests/test_parameters.py

@@ -0,0 +1,178 @@
+import pytest
+from foxglove.websocket import (
+    AnyNativeParameterValue,
+    Parameter,
+    ParameterType,
+    ParameterValue,
+)
+
+
+def test_empty() -> None:
+    p = Parameter("empty")
+    assert p.name == "empty"
+    assert p.type is None
+    assert p.value is None
+    assert p.get_value() is None
+
+
+def test_float() -> None:
+    p = Parameter("float", value=1.234)
+    assert p.name == "float"
+    assert p.type == ParameterType.Float64
+    assert p.value == ParameterValue.Float64(1.234)
+    assert p.get_value() == 1.234
+
+
+def test_int() -> None:
+    p = Parameter("int", value=1)
+    assert p.name == "int"
+    assert p.type is None
+    assert p.value == ParameterValue.Integer(1)
+    assert type(p.get_value()) is int
+    assert p.get_value() == 1
+
+
+def test_float_array() -> None:
+    v: AnyNativeParameterValue = [1.0, 2.0, 3.0]
+    p = Parameter("float_array", value=v)
+    assert p.name == "float_array"
+    assert p.type == ParameterType.Float64Array
+    assert p.value == ParameterValue.Array(
+        [
+            ParameterValue.Float64(1.0),
+            ParameterValue.Float64(2.0),
+            ParameterValue.Float64(3.0),
+        ]
+    )
+    assert p.get_value() == v
+
+
+def test_int_array() -> None:
+    v: AnyNativeParameterValue = [1, 2, 3]
+    p = Parameter("int_array", value=v)
+    assert p.name == "int_array"
+    assert p.type is None
+    assert p.value == ParameterValue.Array(
+        [
+            ParameterValue.Integer(1),
+            ParameterValue.Integer(2),
+            ParameterValue.Integer(3),
+        ]
+    )
+    assert p.get_value() == v
+
+
+def test_parameter_value_integer() -> None:
+    p = Parameter("integer_param", value=ParameterValue.Integer(42))
+    assert p.name == "integer_param"
+    assert p.type is None
+    assert p.value == ParameterValue.Integer(42)
+    assert type(p.get_value()) is int
+    assert p.get_value() == 42
+
+
+def test_heterogeneous_array() -> None:
+    v: AnyNativeParameterValue = ["a", 2, False]
+    p = Parameter("heterogeneous_array", value=v)
+    assert p.name == "heterogeneous_array"
+    assert p.type is None
+    assert p.value == ParameterValue.Array(
+        [
+            ParameterValue.String("a"),
+            ParameterValue.Integer(2),
+            ParameterValue.Bool(False),
+        ]
+    )
+    assert p.get_value() == v
+
+
+def test_string() -> None:
+    p = Parameter("string", value="hello")
+    assert p.name == "string"
+    assert p.type is None
+    assert p.value == ParameterValue.String("hello")
+    assert p.get_value() == "hello"
+
+
+def test_bytes() -> None:
+    p = Parameter("bytes", value=b"hello")
+    assert p.name == "bytes"
+    assert p.type == ParameterType.ByteArray
+    assert p.value == ParameterValue.String("aGVsbG8=")
+    assert p.get_value() == b"hello"
+
+
+def test_dict() -> None:
+    v: AnyNativeParameterValue = {
+        "a": True,
+        "b": 2,
+        "c": "C",
+        "d": {"inner": [1, 2, 3]},
+    }
+    p = Parameter(
+        "dict",
+        value=v,
+    )
+    assert p.name == "dict"
+    assert p.type is None
+    assert p.value == ParameterValue.Dict(
+        {
+            "a": ParameterValue.Bool(True),
+            "b": ParameterValue.Integer(2),
+            "c": ParameterValue.String("C"),
+            "d": ParameterValue.Dict(
+                {
+                    "inner": ParameterValue.Array(
+                        [
+                            ParameterValue.Integer(1),
+                            ParameterValue.Integer(2),
+                            ParameterValue.Integer(3),
+                        ]
+                    )
+                }
+            ),
+        }
+    )
+    assert p.get_value() == v
+
+
+def test_explicit() -> None:
+    # Derive type from value
+    p = Parameter("float", value=ParameterValue.Float64(1))
+    assert p.type == ParameterType.Float64
+    assert p.get_value() == 1
+
+    # Override derived type.
+    p = Parameter(
+        "bad float array",
+        value=ParameterValue.Float64(1),
+        type=ParameterType.Float64Array,
+    )
+    assert p.type == ParameterType.Float64Array
+    assert p.get_value() == 1
+
+    # Override derived type in a different way.
+    p = Parameter(
+        "bad float",
+        value=ParameterValue.String("1"),
+        type=ParameterType.Float64,
+    )
+    assert p.type == ParameterType.Float64
+    assert p.get_value() == "1"
+
+    # Override derived type with None.
+    p = Parameter("underspecified float", value=ParameterValue.Float64(1), type=None)
+    assert p.type is None
+    assert p.get_value() == 1
+
+
+def test_base64_decode_error() -> None:
+    p = Parameter(
+        "bad bytes",
+        value=ParameterValue.String("!!!"),
+        type=ParameterType.ByteArray,
+    )
+    assert p.type == ParameterType.ByteArray
+    assert p.value == ParameterValue.String("!!!")
+    with pytest.raises(ValueError, match=r"Failed to decode base64"):
+        p.get_value()

foxglove/tests/test_schemas.py

@@ -0,0 +1,17 @@
+from foxglove.schemas import Log, LogLevel, Timestamp
+
+""" Asserts that foxglove schemas can be encoded as protobuf. """
+
+
+def test_can_encode() -> None:
+    msg = Log(
+        timestamp=Timestamp(5, 10),
+        level=LogLevel.Error,
+        message="hello",
+        name="logger",
+        file="file",
+        line=123,
+    )
+    encoded = msg.encode()
+    assert isinstance(encoded, bytes)
+    assert len(encoded) == 34

foxglove/tests/test_server.py

@@ -0,0 +1,141 @@
+import time
+import typing
+from urllib.parse import parse_qs, urlparse
+
+import pytest
+from foxglove import (
+    Capability,
+    Channel,
+    Context,
+    ServerListener,
+    Service,
+    start_server,
+)
+from foxglove.websocket import PlaybackState, PlaybackStatus, ServiceSchema, StatusLevel
+
+
+def test_server_interface() -> None:
+    """
+    Exercise the server interface; will also be checked with mypy.
+    """
+    server = start_server(
+        port=0, session_id="test-session", channel_filter=lambda _: True
+    )
+    assert isinstance(server.port, int)
+    assert server.port != 0
+
+    raw_url = server.app_url()
+    assert raw_url is not None
+    url = urlparse(raw_url)
+    assert url.scheme == "https"
+    assert url.netloc == "app.foxglove.dev"
+    assert parse_qs(url.query) == {
+        "ds": ["foxglove-websocket"],
+        "ds.url": [f"ws://127.0.0.1:{server.port}"],
+    }
+
+    raw_url = server.app_url(layout_id="lay_123", open_in_desktop=True)
+    assert raw_url is not None
+    url = urlparse(raw_url)
+    assert url.scheme == "https"
+    assert url.netloc == "app.foxglove.dev"
+    assert parse_qs(url.query) == {
+        "ds": ["foxglove-websocket"],
+        "ds.url": [f"ws://127.0.0.1:{server.port}"],
+        "layoutId": ["lay_123"],
+        "openIn": ["desktop"],
+    }
+
+    server.publish_status("test message", StatusLevel.Info, "some-id")
+    server.broadcast_time(time.time_ns())
+    server.broadcast_playback_state(
+        PlaybackState(
+            status=PlaybackStatus.Paused,
+            playback_speed=1.0,
+            current_time=time.time_ns(),
+            did_seek=False,
+            request_id=None,
+        )
+    )
+    server.remove_status(["some-id"])
+    server.clear_session("new-session")
+    server.stop()
+
+
+def test_server_listener_provides_default_implementation() -> None:
+    class DefaultServerListener(ServerListener):
+        pass
+
+    listener = DefaultServerListener()
+
+    listener.on_parameters_subscribe(["test"])
+    listener.on_parameters_unsubscribe(["test"])
+
+
+def test_services_interface() -> None:
+    test_svc = Service(
+        name="test",
+        schema=ServiceSchema(name="test-schema"),
+        handler=lambda *_: b"{}",
+    )
+    test2_svc = Service(
+        name="test2",
+        schema=ServiceSchema(name="test-schema"),
+        handler=lambda *_: b"{}",
+    )
+    server = start_server(
+        port=0,
+        capabilities=[Capability.Services],
+        supported_encodings=["json"],
+        services=[test_svc],
+    )
+
+    # Add a new service.
+    server.add_services([test2_svc])
+
+    # Can't add a service with the same name.
+    with pytest.raises(RuntimeError):
+        server.add_services([test_svc])
+
+    # Remove services.
+    server.remove_services(["test", "test2"])
+
+    # Re-add a service.
+    server.add_services([test_svc])
+
+    server.stop()
+
+
+def test_context_can_be_attached_to_server() -> None:
+    ctx1 = Context()
+    ctx2 = Context()
+
+    server1 = start_server(port=0, context=ctx1)
+    server2 = start_server(port=0, context=ctx2)
+
+    ch1 = Channel("/1", context=ctx1)
+    ch2 = Channel("/2", context=ctx2)
+    ch1.log("test")
+    ch2.log("test")
+
+    server1.stop()
+    server2.stop()
+
+
+@typing.no_type_check
+def test_server_with_invalid_playback_time_range() -> None:
+    with pytest.raises(TypeError):
+        # Tuple of a single element
+        start_server(port=0, playback_time_range=(123,))
+
+    with pytest.raises(TypeError):
+        # Tuple with invalid types
+        start_server(port=0, playback_time_range=("not-a-time", None))
+
+    with pytest.raises(TypeError):
+        # Not a tuple
+        start_server(port=0, playback_time_range=23443)
+
+    with pytest.raises(TypeError):
+        # Tuple with too many elements
+        start_server(port=0, playback_time_range=(123, 456, 789))