foxglove-sdk 0.16.1__cp314-cp314-win_amd64.whl

foxglove/schemas/__init__.py

@@ -0,0 +1,163 @@
+"""
+This module contains the definitions of the well-known Foxglove schemas for logging.
+
+Log messages to a corresponding channel type from :py:mod:`foxglove.channels`.
+
+Note that the schema classes are currently immutable and do not expose
+getters and setters for their fields. This is a limitation we plan to address in the future.
+"""
+
+# Generated by https://github.com/foxglove/foxglove-sdk
+
+from typing import Union
+
+from foxglove._foxglove_py.schemas import (
+    ArrowPrimitive,
+    CameraCalibration,
+    CircleAnnotation,
+    Color,
+    CompressedImage,
+    CompressedVideo,
+    CubePrimitive,
+    CylinderPrimitive,
+    Duration,
+    FrameTransform,
+    FrameTransforms,
+    GeoJson,
+    Grid,
+    ImageAnnotations,
+    KeyValuePair,
+    LaserScan,
+    LinePrimitive,
+    LinePrimitiveLineType,
+    LocationFix,
+    LocationFixes,
+    LocationFixPositionCovarianceType,
+    Log,
+    LogLevel,
+    ModelPrimitive,
+    PackedElementField,
+    PackedElementFieldNumericType,
+    Point2,
+    Point3,
+    PointCloud,
+    PointsAnnotation,
+    PointsAnnotationType,
+    Pose,
+    PoseInFrame,
+    PosesInFrame,
+    Quaternion,
+    RawAudio,
+    RawImage,
+    SceneEntity,
+    SceneEntityDeletion,
+    SceneEntityDeletionType,
+    SceneUpdate,
+    SpherePrimitive,
+    TextAnnotation,
+    TextPrimitive,
+    Timestamp,
+    TriangleListPrimitive,
+    Vector2,
+    Vector3,
+    VoxelGrid,
+)
+
+FoxgloveSchema = Union[
+    ArrowPrimitive,
+    CameraCalibration,
+    CircleAnnotation,
+    Color,
+    CompressedImage,
+    CompressedVideo,
+    CubePrimitive,
+    CylinderPrimitive,
+    Duration,
+    FrameTransform,
+    FrameTransforms,
+    GeoJson,
+    Grid,
+    ImageAnnotations,
+    KeyValuePair,
+    LaserScan,
+    LinePrimitive,
+    LocationFix,
+    LocationFixes,
+    Log,
+    ModelPrimitive,
+    PackedElementField,
+    Point2,
+    Point3,
+    PointCloud,
+    PointsAnnotation,
+    Pose,
+    PoseInFrame,
+    PosesInFrame,
+    Quaternion,
+    RawAudio,
+    RawImage,
+    SceneEntity,
+    SceneEntityDeletion,
+    SceneUpdate,
+    SpherePrimitive,
+    TextAnnotation,
+    TextPrimitive,
+    Timestamp,
+    TriangleListPrimitive,
+    Vector2,
+    Vector3,
+    VoxelGrid,
+]
+
+__all__ = [
+    "FoxgloveSchema",
+    "ArrowPrimitive",
+    "CameraCalibration",
+    "CircleAnnotation",
+    "Color",
+    "CompressedImage",
+    "CompressedVideo",
+    "CubePrimitive",
+    "CylinderPrimitive",
+    "Duration",
+    "FrameTransform",
+    "FrameTransforms",
+    "GeoJson",
+    "Grid",
+    "ImageAnnotations",
+    "KeyValuePair",
+    "LaserScan",
+    "LinePrimitive",
+    "LinePrimitiveLineType",
+    "LocationFix",
+    "LocationFixPositionCovarianceType",
+    "LocationFixes",
+    "Log",
+    "LogLevel",
+    "ModelPrimitive",
+    "PackedElementField",
+    "PackedElementFieldNumericType",
+    "Point2",
+    "Point3",
+    "PointCloud",
+    "PointsAnnotation",
+    "PointsAnnotationType",
+    "Pose",
+    "PoseInFrame",
+    "PosesInFrame",
+    "Quaternion",
+    "RawAudio",
+    "RawImage",
+    "SceneEntity",
+    "SceneEntityDeletion",
+    "SceneEntityDeletionType",
+    "SceneUpdate",
+    "SpherePrimitive",
+    "TextAnnotation",
+    "TextPrimitive",
+    "Timestamp",
+    "TriangleListPrimitive",
+    "Vector2",
+    "Vector3",
+    "VoxelGrid",
+]

foxglove/tests/test_channel.py

@@ -0,0 +1,243 @@
+import json
+import logging
+import random
+
+import pytest
+from foxglove import Channel, Context, Schema
+from foxglove.channels import LogChannel
+from foxglove.schemas import Log
+
+
+@pytest.fixture
+def new_topic() -> str:
+    return f"/{random.random()}"
+
+
+def test_warns_on_duplicate_topics(caplog: pytest.LogCaptureFixture) -> None:
+    schema = {"type": "object"}
+    c1 = Channel("test-duplicate", schema=schema)
+    c2 = Channel("test-duplicate", schema=schema)
+    assert c1.id() == c2.id()
+
+    with caplog.at_level(logging.WARNING):
+        # Same topic, different schema
+        c3 = Channel(
+            "test-duplicate",
+            schema={
+                "type": "object",
+                "additionalProperties": False,
+            },
+        )
+        assert c1.id() != c3.id()
+
+    assert len(caplog.records) == 1
+    for _, _, message in caplog.record_tuples:
+        assert (
+            "Channel with topic test-duplicate already exists in this context"
+            in message
+        )
+
+
+def test_does_not_warn_on_duplicate_topics_in_contexts(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    ctx1 = Context()
+    ctx2 = Context()
+
+    _ = Channel("test-duplicate", context=ctx1)
+
+    with caplog.at_level(logging.WARNING):
+        Channel("test-duplicate", context=ctx2)
+
+    assert len(caplog.records) == 0
+
+
+def test_requires_an_object_schema(new_topic: str) -> None:
+    schema = {"type": "array"}
+    with pytest.raises(ValueError, match="Only object schemas are supported"):
+        Channel(new_topic, schema=schema)
+
+
+def test_log_dict_on_json_channel(new_topic: str) -> None:
+    json_schema = {"type": "object", "additionalProperties": True}
+    channel = Channel(new_topic, schema=json_schema)
+
+    assert channel.message_encoding == "json"
+
+    schema = channel.schema()
+    assert schema is not None
+    assert schema.encoding == "jsonschema"
+    assert json.loads(schema.data) == json_schema
+
+    channel.log({"test": "test"})
+
+
+def test_log_dict_on_schemaless_channel(new_topic: str) -> None:
+    channel = Channel(new_topic)
+    assert channel.message_encoding == "json"
+
+    schema = channel.schema()
+    assert schema is not None
+    assert schema.encoding == "jsonschema"
+    assert schema.data == b""
+
+    channel.log({"test": "test"})
+
+
+def test_log_dict_with_empty_schema(new_topic: str) -> None:
+    channel = Channel(new_topic, schema={})
+    assert channel.message_encoding == "json"
+
+    schema = channel.schema()
+    assert schema is not None
+    assert schema.encoding == "jsonschema"
+    assert schema.data == b""
+
+    channel.log({"test": "test"})
+
+
+def test_log_dict_on_schemaless_json_channel(new_topic: str) -> None:
+    channel = Channel(
+        new_topic,
+        message_encoding="json",
+    )
+    assert channel.message_encoding == "json"
+
+    schema = channel.schema()
+    assert schema is not None
+    assert schema.encoding == "jsonschema"
+    assert schema.data == b""
+
+    channel.log({"test": "test"})
+
+
+def test_log_must_serialize_on_protobuf_channel(new_topic: str) -> None:
+    schema = Schema(
+        name="my_schema",
+        encoding="protobuf",
+        data=b"\x01",
+    )
+    channel = Channel(
+        new_topic,
+        message_encoding="protobuf",
+        schema=schema,
+    )
+
+    assert channel.message_encoding == "protobuf"
+    assert channel.schema() == schema
+
+    with pytest.raises(TypeError, match="Unsupported message type"):
+        channel.log({"test": "test"})
+
+    channel.log(b"\x01")
+
+
+def test_channel_attributes(new_topic: str) -> None:
+    channel = Channel(new_topic, message_encoding="json")
+    assert channel.topic() == new_topic
+    assert channel.message_encoding == "json"
+    assert channel.schema() is not None
+    assert channel.metadata() == {}
+    assert not channel.has_sinks()
+
+
+def test_typed_channel_attributes(new_topic: str) -> None:
+    channel = LogChannel(new_topic)
+    assert channel.topic() == new_topic
+    assert channel.message_encoding == "protobuf"
+    assert channel.schema() == Log.get_schema()
+    assert channel.metadata() == {}
+    assert not channel.has_sinks()
+
+
+def test_channel_metadata(new_topic: str) -> None:
+    channel = Channel(new_topic, metadata={"foo": "bar"})
+    assert channel.metadata() == {"foo": "bar"}
+
+
+def test_channel_metadata_mistyped(new_topic: str) -> None:
+    with pytest.raises(TypeError, match="argument 'metadata'"):
+        Channel(new_topic, metadata={"1": 1})  # type: ignore
+
+
+def test_typed_channel_metadata(new_topic: str) -> None:
+    channel = LogChannel(new_topic, metadata={"foo": "bar"})
+    assert channel.metadata() == {"foo": "bar"}
+    channel = LogChannel(new_topic, context=Context(), metadata={"foo": "baz"})
+    assert channel.metadata() == {"foo": "baz"}
+
+
+def test_typed_channel_metadata_mistyped(new_topic: str) -> None:
+    with pytest.raises(TypeError, match="argument 'metadata'"):
+        LogChannel(new_topic, metadata={"1": 1})  # type: ignore
+
+
+def test_closed_channel_log(new_topic: str, caplog: pytest.LogCaptureFixture) -> None:
+    channel = Channel(new_topic, schema={"type": "object"})
+    channel.close()
+    with caplog.at_level(logging.WARNING):
+        channel.log(b"\x01")
+
+    assert len(caplog.records) == 1
+    for log_name, _, message in caplog.record_tuples:
+        assert log_name == "foxglove.channel.raw_channel"
+        assert message == f"Cannot log on closed channel for {new_topic}"
+
+
+def test_close_typed_channel(new_topic: str, caplog: pytest.LogCaptureFixture) -> None:
+    channel = LogChannel(new_topic)
+    channel.close()
+    with caplog.at_level(logging.WARNING):
+        channel.log(Log())
+
+    assert len(caplog.records) == 1
+    for log_name, _, message in caplog.record_tuples:
+        assert log_name == "foxglove.channel.raw_channel"
+        assert message == f"Cannot log on closed channel for {new_topic}"
+
+
+def test_typed_channel_requires_kwargs_after_message(new_topic: str) -> None:
+    channel = LogChannel(new_topic)
+
+    channel.log(Log(), log_time=0)
+
+    with pytest.raises(
+        TypeError,
+        match="takes 1 positional arguments but 2 were given",
+    ):
+        channel.log(Log(), 0)  # type: ignore
+
+
+def test_generates_names_for_schemas(new_topic: str) -> None:
+    ch_1 = Channel(
+        new_topic + "-1",
+        schema={"type": "object", "properties": {"foo": {"type": "string"}}},
+    )
+    ch_2 = Channel(
+        new_topic + "-2",
+        schema={"type": "object", "additionalProperties": True},
+    )
+    # Same schema will have the same name
+    ch_3 = Channel(
+        new_topic + "-3",
+        schema={"type": "object", "additionalProperties": True},
+    )
+
+    assert ch_1.schema_name() != ch_2.schema_name()
+    assert ch_2.schema_name() == ch_3.schema_name()
+
+
+def test_exposes_unique_channel_ids(new_topic: str) -> None:
+    ch_1 = Channel(new_topic + "-1")
+    ch_2 = Channel(new_topic + "-2")
+    ch_3 = LogChannel(new_topic + "-3")
+
+    assert ch_1.id() > 0
+    assert ch_1.id() < ch_2.id()
+    assert ch_2.id() < ch_3.id()
+
+
+def test_log_message_to_specific_sink(new_topic: str) -> None:
+    ctx = Context()
+    ch = Channel(new_topic, context=ctx)
+    ch.log("test", sink_id=1)

foxglove/tests/test_context.py

@@ -0,0 +1,10 @@
+from foxglove import Context
+
+
+def test_default_context_is_singleton() -> None:
+    assert Context.default() is Context.default()
+
+
+def test_context_is_distinct() -> None:
+    assert Context() is not Context.default()
+    assert Context() is not Context()

foxglove/tests/test_logging.py

@@ -0,0 +1,62 @@
+import logging
+import os
+import subprocess
+import sys
+
+import pytest
+from foxglove import set_log_level
+
+
+def test_set_log_level_accepts_string_or_int() -> None:
+    set_log_level("DEBUG")
+    set_log_level(logging.DEBUG)
+    with pytest.raises(ValueError):
+        set_log_level("debug")
+
+
+def test_set_log_level_clamps_illegal_values() -> None:
+    set_log_level(-1)
+    set_log_level(2**64)
+
+
+def test_logging_config_with_env() -> None:
+    # Run a script in a child process so logger can be re-initialized from env.
+    test_script = """
+import logging
+import foxglove
+
+logging.basicConfig(level=logging.DEBUG)
+
+server = foxglove.start_server(port=0)
+server.stop()
+
+print("test_init_with_env_complete")
+"""
+
+    # Default: unset
+    env = os.environ.copy()
+    env["FOXGLOVE_LOG_LEVEL"] = ""
+
+    result = subprocess.run(
+        [sys.executable, "-c", test_script],
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=5,
+    )
+    assert "test_init_with_env_complete" in result.stdout
+    assert "Started server" in result.stderr
+
+    # Quiet the WS server logging
+    env = os.environ.copy()
+    env["FOXGLOVE_LOG_LEVEL"] = "debug,foxglove::websocket::server=warn"
+
+    result = subprocess.run(
+        [sys.executable, "-c", test_script],
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=5,
+    )
+    assert "test_init_with_env_complete" in result.stdout
+    assert "Started server" not in result.stderr

foxglove/tests/test_mcap.py

@@ -0,0 +1,199 @@
+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 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