foxglove-sdk 0.8.1__cp312-cp312-win32.whl → 0.16.3__cp312-cp312-win32.whl

foxglove/tests/test_parameters.py

@@ -1,154 +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.Number(1.234)
-    assert p.get_value() == 1.234
-
-
-def test_int() -> None:
-    p = Parameter("int", value=1)
-    assert p.name == "int"
-    assert p.type == ParameterType.Float64
-    assert p.value == ParameterValue.Number(1)
-    assert type(p.get_value()) is float
-    assert p.get_value() == 1
-
-
-def test_float_array() -> None:
-    v: AnyNativeParameterValue = [1, 2, 3]
-    p = Parameter("float_array", value=v)
-    assert p.name == "float_array"
-    assert p.type == ParameterType.Float64Array
-    assert p.value == ParameterValue.Array(
-        [
-            ParameterValue.Number(1),
-            ParameterValue.Number(2),
-            ParameterValue.Number(3),
-        ]
-    )
-    assert p.get_value() == v
-
-
-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.Number(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.Number(2),
-            "c": ParameterValue.String("C"),
-            "d": ParameterValue.Dict(
-                {
-                    "inner": ParameterValue.Array(
-                        [
-                            ParameterValue.Number(1),
-                            ParameterValue.Number(2),
-                            ParameterValue.Number(3),
-                        ]
-                    )
-                }
-            ),
-        }
-    )
-    assert p.get_value() == v
-
-
-def test_explicit() -> None:
-    # Derive type from value
-    p = Parameter("float", value=ParameterValue.Number(1))
-    assert p.type == ParameterType.Float64
-    assert p.get_value() == 1
-
-    # Override derived type.
-    p = Parameter(
-        "bad float array",
-        value=ParameterValue.Number(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.Number(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()
+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

@@ -1,110 +1,141 @@
-import time
-from urllib.parse import parse_qs, urlparse
-
-import pytest
-from foxglove import (
-    Capability,
-    Channel,
-    Context,
-    ServerListener,
-    Service,
-    start_server,
-)
-from foxglove.websocket import ServiceSchema, StatusLevel
-
-
-def test_server_interface() -> None:
-    """
-    Exercise the server interface; will also be checked with mypy.
-    """
-    server = start_server(port=0)
-    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.remove_status(["some-id"])
-    server.clear_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()
+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))