foxglove-sdk 0.14.1__cp312-cp312-musllinux_1_2_i686.whl → 0.16.6__cp312-cp312-musllinux_1_2_i686.whl

foxglove/_foxglove_py/schemas_wkt.pyi

@@ -1,16 +1,15 @@
 import datetime
-from typing import Optional
 
 class Duration:
     """
     A duration in seconds and nanoseconds
     """
 
-    def __new__(
-        cls,
+    def __init__(
+        self,
         sec: int,
-        nsec: Optional[int] = None,
-    ) -> "Duration": ...
+        nsec: int | None = None,
+    ) -> None: ...
     @property
     def sec(self) -> int: ...
     @property
@@ -42,11 +41,11 @@ class Timestamp:
     A timestamp in seconds and nanoseconds
     """
 
-    def __new__(
-        cls,
+    def __init__(
+        self,
         sec: int,
-        nsec: Optional[int] = None,
-    ) -> "Timestamp": ...
+        nsec: int | None = None,
+    ) -> None: ...
     @property
     def sec(self) -> int: ...
     @property

foxglove/_foxglove_py/websocket.pyi

@@ -1,8 +1,11 @@
-from collections.abc import Callable
 from enum import Enum
-from typing import Dict, List, Optional, Union
 
-import foxglove
+from foxglove import Schema
+from foxglove.websocket import (
+    AnyNativeParameterValue,
+    AnyParameterValue,
+    ServiceHandler,
+)
 
 class Capability(Enum):
     """
@@ -12,7 +15,7 @@ class Capability(Enum):
     ClientPublish = ...
     """Allow clients to advertise channels to send data messages to the server."""
 
-    Connectiongraph = ...
+    ConnectionGraph = ...
     """Allow clients to subscribe and make connection graph updates"""
 
     Parameters = ...
@@ -24,6 +27,9 @@ class Capability(Enum):
     Time = ...
     """Inform clients about the latest server time."""
 
+    RangedPlayback = ...
+    """Indicates that the server is sending data within a fixed time range."""
+
 class Client:
     """
     A client that is connected to a running websocket server.
@@ -48,16 +54,16 @@ class ClientChannel:
     topic: str = ...
     encoding: str = ...
     schema_name: str = ...
-    schema_encoding: Optional[str] = ...
-    schema: Optional[bytes] = ...
+    schema_encoding: str | None = ...
+    schema: bytes | None = ...
 
 class ConnectionGraph:
     """
     A graph of connections between clients.
     """
 
-    def __new__(cls) -> "ConnectionGraph": ...
-    def set_published_topic(self, topic: str, publisher_ids: List[str]) -> None:
+    def __init__(self) -> None: ...
+    def set_published_topic(self, topic: str, publisher_ids: list[str]) -> None:
         """
         Set a published topic and its associated publisher ids. Overwrites any existing topic with
         the same name.
@@ -67,7 +73,7 @@ class ConnectionGraph:
         """
         ...
 
-    def set_subscribed_topic(self, topic: str, subscriber_ids: List[str]) -> None:
+    def set_subscribed_topic(self, topic: str, subscriber_ids: list[str]) -> None:
         """
         Set a subscribed topic and its associated subscriber ids. Overwrites any existing topic with
         the same name.
@@ -77,7 +83,7 @@ class ConnectionGraph:
         """
         ...
 
-    def set_advertised_service(self, service: str, provider_ids: List[str]) -> None:
+    def set_advertised_service(self, service: str, provider_ids: list[str]) -> None:
         """
         Set an advertised service and its associated provider ids Overwrites any existing service
         with the same name.
@@ -93,14 +99,14 @@ class MessageSchema:
     """
 
     encoding: str
-    schema: "foxglove.Schema"
+    schema: Schema
 
-    def __new__(
-        cls,
+    def __init__(
+        self,
         *,
         encoding: str,
-        schema: "foxglove.Schema",
-    ) -> "MessageSchema": ...
+        schema: Schema,
+    ) -> None: ...
 
 class Parameter:
     """
@@ -116,17 +122,17 @@ class Parameter:
     """
 
     name: str
-    type: Optional["ParameterType"]
-    value: Optional["AnyParameterValue"]
+    type: ParameterType | None
+    value: AnyParameterValue | None
 
     def __init__(
         self,
         name: str,
         *,
-        value: Optional["AnyNativeParameterValue"] = None,
-        type: Optional["ParameterType"] = None,
+        value: AnyNativeParameterValue | None = None,
+        type: ParameterType | None = None,
     ) -> None: ...
-    def get_value(self) -> Optional["AnyNativeParameterValue"]:
+    def get_value(self) -> AnyNativeParameterValue | None:
         """Returns the parameter value as a native python object."""
         ...
 
@@ -152,17 +158,17 @@ class ParameterValue:
     class Integer:
         """An integer value."""
 
-        def __new__(cls, value: int) -> "ParameterValue.Integer": ...
+        def __init__(self, value: int) -> None: ...
 
     class Bool:
         """A boolean value."""
 
-        def __new__(cls, value: bool) -> "ParameterValue.Bool": ...
+        def __init__(self, value: bool) -> None: ...
 
     class Float64:
         """A floating-point value."""
 
-        def __new__(cls, value: float) -> "ParameterValue.Float64": ...
+        def __init__(self, value: float) -> None: ...
 
     class String:
         """
@@ -172,47 +178,81 @@ class ParameterValue:
         base64 encoding of the byte array.
         """
 
-        def __new__(cls, value: str) -> "ParameterValue.String": ...
+        def __init__(self, value: str) -> None: ...
 
     class Array:
         """An array of parameter values."""
 
-        def __new__(
-            cls, value: List["AnyParameterValue"]
-        ) -> "ParameterValue.Array": ...
+        def __init__(self, value: list[AnyParameterValue]) -> None: ...
 
     class Dict:
         """An associative map of parameter values."""
 
-        def __new__(
-            cls, value: dict[str, "AnyParameterValue"]
-        ) -> "ParameterValue.Dict": ...
+        def __init__(self, value: dict[str, AnyParameterValue]) -> None: ...
 
-AnyParameterValue = Union[
-    ParameterValue.Integer,
-    ParameterValue.Bool,
-    ParameterValue.Float64,
-    ParameterValue.String,
-    ParameterValue.Array,
-    ParameterValue.Dict,
-]
+class PlaybackCommand(Enum):
+    """The command for playback requested by the client player"""
 
-AnyInnerParameterValue = Union[
-    AnyParameterValue,
-    bool,
-    int,
-    float,
-    str,
-    List["AnyInnerParameterValue"],
-    Dict[str, "AnyInnerParameterValue"],
-]
+    Play = ...
+    Pause = ...
+
+class PlaybackControlRequest:
+    """
+    A request to control playback from the client
+
+    :param playback_command: The command for playback requested by the client player
+    :type playback_command: PlaybackCommand
+    :param playback_speed: The speed of playback requested by the client player
+    :type playback_speed: float
+    :param seek_time: The time the client player is requesting to seek to, in nanoseconds. None if no seek is requested.
+    :type seek_time: int | None
+    :param request_id: Unique string identifier, used to indicate that a PlaybackState is in response to a particular request from the client.
+    :type request_id: str
+    """
+
+    playback_command: PlaybackCommand
+    playback_speed: float
+    seek_time: int | None
+    request_id: str
+
+class PlaybackState:
+    """
+    The state of data playback on the server
+
+    :param status: The status of server data playback
+    :type status: PlaybackStatus
+    :param current_time: The current time of playback, in absolute nanoseconds
+    :type current_time: int
+    :param playback_speed: The speed of playback, as a factor of realtime
+    :type playback_speed: float
+    :param did_seek: Whether a seek forward or backward in time triggered this message to be emitted
+    :type did_seek: bool
+    :param request_id: If this message is being emitted in response to a PlaybackControlRequest message, the request_id from that message. Set this to an empty string if the state of playback has been changed by any other condition.
+    :type request_id: str | None
+    """
 
-AnyNativeParameterValue = Union[
-    AnyInnerParameterValue,
-    bytes,
-]
+    status: PlaybackStatus
+    current_time: int
+    playback_speed: float
+    did_seek: bool
+    request_id: str | None
 
-AssetHandler = Callable[[str], Optional[bytes]]
+    def __init__(
+        self,
+        status: PlaybackStatus,
+        current_time: int,
+        playback_speed: float,
+        did_seek: bool,
+        request_id: str | None,
+    ): ...
+
+class PlaybackStatus(Enum):
+    """The status of server data playback"""
+
+    Playing = ...
+    Paused = ...
+    Buffering = ...
+    Ended = ...
 
 class ServiceRequest:
     """
@@ -225,24 +265,22 @@ class ServiceRequest:
     encoding: str
     payload: bytes
 
-ServiceHandler = Callable[["ServiceRequest"], bytes]
-
 class Service:
     """
     A websocket service.
     """
 
     name: str
-    schema: "ServiceSchema"
-    handler: "ServiceHandler"
+    schema: ServiceSchema
+    handler: ServiceHandler
 
-    def __new__(
-        cls,
+    def __init__(
+        self,
         *,
         name: str,
-        schema: "ServiceSchema",
-        handler: "ServiceHandler",
-    ) -> "Service": ...
+        schema: ServiceSchema,
+        handler: ServiceHandler,
+    ): ...
 
 class ServiceSchema:
     """
@@ -250,16 +288,16 @@ class ServiceSchema:
     """
 
     name: str
-    request: Optional["MessageSchema"]
-    response: Optional["MessageSchema"]
+    request: MessageSchema | None
+    response: MessageSchema | None
 
-    def __new__(
-        cls,
+    def __init__(
+        self,
         *,
         name: str,
-        request: Optional["MessageSchema"] = None,
-        response: Optional["MessageSchema"] = None,
-    ) -> "ServiceSchema": ...
+        request: MessageSchema | None = None,
+        response: MessageSchema | None = None,
+    ): ...
 
 class StatusLevel(Enum):
     """A level for `WebSocketServer.publish_status`"""
@@ -273,7 +311,7 @@ class WebSocketServer:
     A websocket server for live visualization.
     """
 
-    def __new__(cls) -> "WebSocketServer": ...
+    def __init__(self) -> None: ...
     @property
     def port(self) -> int:
         """Get the port on which the server is listening."""
@@ -282,9 +320,9 @@ class WebSocketServer:
     def app_url(
         self,
         *,
-        layout_id: Optional[str] = None,
+        layout_id: str | None = None,
         open_in_desktop: bool = False,
-    ) -> Optional[str]:
+    ) -> str | None:
         """
         Returns a web app URL to open the websocket as a data source.
 
@@ -299,7 +337,7 @@ class WebSocketServer:
         """Explicitly stop the server."""
         ...
 
-    def clear_session(self, session_id: Optional[str] = None) -> None:
+    def clear_session(self, session_id: str | None = None) -> None:
         """
         Sets a new session ID and notifies all clients, causing them to reset their state.
         If no session ID is provided, generates a new one based on the current timestamp.
@@ -307,6 +345,12 @@ class WebSocketServer:
         """
         ...
 
+    def broadcast_playback_state(self, playback_state: PlaybackState) -> None:
+        """
+        Publish the current playback state to all clients.
+        """
+        ...
+
     def broadcast_time(self, timestamp_nanos: int) -> None:
         """
         Publishes the current server timestamp to all clients.
@@ -314,12 +358,12 @@ class WebSocketServer:
         """
         ...
 
-    def publish_parameter_values(self, parameters: List["Parameter"]) -> None:
+    def publish_parameter_values(self, parameters: list[Parameter]) -> None:
         """Publishes parameter values to all subscribed clients."""
         ...
 
     def publish_status(
-        self, message: str, level: "StatusLevel", id: Optional[str] = None
+        self, message: str, level: StatusLevel, id: str | None = None
     ) -> None:
         """
         Send a status message to all clients. If the server has been stopped, this has no effect.
@@ -333,7 +377,7 @@ class WebSocketServer:
         """
         ...
 
-    def add_services(self, services: list["Service"]) -> None:
+    def add_services(self, services: list[Service]) -> None:
         """Add services to the server."""
         ...
 
@@ -341,7 +385,7 @@ class WebSocketServer:
         """Removes services that were previously advertised."""
         ...
 
-    def publish_connection_graph(self, graph: "ConnectionGraph") -> None:
+    def publish_connection_graph(self, graph: ConnectionGraph) -> None:
         """
         Publishes a connection graph update to all subscribed clients. An update is published to
         clients as a difference from the current graph to the replacement graph. When a client first

foxglove/channel.py

@@ -1,15 +1,17 @@
+from __future__ import annotations
+
 import hashlib
 import json
 from base64 import b64encode
-from typing import Any, Dict, Optional, Union, cast
+from typing import Any, cast
 
 from . import Context
 from . import _foxglove_py as _foxglove
 from . import channels as _channels
 from . import schemas as _schemas
 
-JsonSchema = Dict[str, Any]
-JsonMessage = Dict[str, Any]
+JsonSchema = dict[str, Any]
+JsonMessage = dict[str, Any]
 
 
 class Channel:
@@ -24,16 +26,16 @@ class Channel:
         self,
         topic: str,
         *,
-        schema: Union[JsonSchema, _foxglove.Schema, None] = None,
-        message_encoding: Optional[str] = None,
-        context: Optional[Context] = None,
-        metadata: Optional[Dict[str, str]] = None,
-    ):
+        schema: JsonSchema | _foxglove.Schema | None = None,
+        message_encoding: str | None = None,
+        context: Context | None = None,
+        metadata: dict[str, str] | None = None,
+    ) -> None:
         """
         Create a new channel for logging messages on a topic.
 
         :param topic: The topic name. You should choose a unique topic name per channel.
-        :param message_encoding: The message encoding. Optional if :py:param:`schema` is a
+        :param message_encoding: The message encoding. Optional if :any:`schema` is a
             dictionary, in which case the message encoding is presumed to be "json".
         :param schema: A definition of your schema. Pass a :py:class:`Schema` for full control. If a
             dictionary is passed, it will be treated as a JSON schema.
@@ -75,7 +77,7 @@ class Channel:
         """The message encoding for the channel"""
         return self.base.message_encoding
 
-    def metadata(self) -> Dict[str, str]:
+    def metadata(self) -> dict[str, str]:
         """
         Returns a copy of the channel's metadata.
 
@@ -84,7 +86,7 @@ class Channel:
         """
         return self.base.metadata()
 
-    def schema(self) -> Optional[_foxglove.Schema]:
+    def schema(self) -> _foxglove.Schema | None:
         """
         Returns a copy of the channel's metadata.
 
@@ -93,7 +95,7 @@ class Channel:
         """
         return self.base.schema()
 
-    def schema_name(self) -> Optional[str]:
+    def schema_name(self) -> str | None:
         """The name of the schema for the channel"""
         return self.base.schema_name()
 
@@ -103,10 +105,10 @@ class Channel:
 
     def log(
         self,
-        msg: Union[JsonMessage, list[Any], bytes, str],
+        msg: JsonMessage | list[Any] | bytes | str,
         *,
-        log_time: Optional[int] = None,
-        sink_id: Optional[int] = None,
+        log_time: int | None = None,
+        sink_id: int | None = None,
     ) -> None:
         """
         Log a message on the channel.
@@ -138,15 +140,15 @@ class Channel:
         self.base.close()
 
 
-_channels_by_id: Dict[int, Channel] = {}
+_channels_by_id: dict[int, Channel] = {}
 
 
 def log(
     topic: str,
-    message: Union[JsonMessage, list[Any], bytes, str, _schemas.FoxgloveSchema],
+    message: JsonMessage | list[Any] | bytes | str | _schemas.FoxgloveSchema,
     *,
-    log_time: Optional[int] = None,
-    sink_id: Optional[int] = None,
+    log_time: int | None = None,
+    sink_id: int | None = None,
 ) -> None:
     """Log a message on a topic.
 
@@ -197,9 +199,9 @@ def log(
 
 
 def _normalize_schema(
-    message_encoding: Optional[str],
-    schema: Union[JsonSchema, _foxglove.Schema, None] = None,
-) -> tuple[str, Optional[_foxglove.Schema]]:
+    message_encoding: str | None,
+    schema: JsonSchema | _foxglove.Schema | None = None,
+) -> tuple[str, _foxglove.Schema | None]:
     if isinstance(schema, _foxglove.Schema):
         if message_encoding is None:
             raise ValueError("message encoding is required")

foxglove/channels/__init__.py

@@ -29,6 +29,7 @@ from foxglove._foxglove_py.channels import (
     PackedElementFieldChannel,
     Point2Channel,
     Point3Channel,
+    Point3InFrameChannel,
     PointCloudChannel,
     PointsAnnotationChannel,
     PoseChannel,
@@ -73,6 +74,7 @@ __all__ = [
     "PackedElementFieldChannel",
     "Point2Channel",
     "Point3Channel",
+    "Point3InFrameChannel",
     "PointCloudChannel",
     "PointsAnnotationChannel",
     "PoseChannel",

foxglove/cloud.py

@@ -0,0 +1,61 @@
+from typing import Protocol
+
+from ._foxglove_py.websocket import (
+    ChannelView,
+    Client,
+    ClientChannel,
+)
+
+
+class CloudSinkListener(Protocol):
+    """
+    A mechanism to register callbacks for handling client message events.
+    """
+
+    def on_subscribe(self, client: Client, channel: ChannelView) -> None:
+        """
+        Called when a client subscribes to a channel.
+
+        :param client: The client (id) that sent the message.
+        :param channel: The channel (id, topic) that the message was sent on.
+        """
+        return None
+
+    def on_unsubscribe(self, client: Client, channel: ChannelView) -> None:
+        """
+        Called when a client unsubscribes from a channel or disconnects.
+
+        :param client: The client (id) that sent the message.
+        :param channel: The channel (id, topic) that the message was sent on.
+        """
+        return None
+
+    def on_client_advertise(self, client: Client, channel: ClientChannel) -> None:
+        """
+        Called when a client advertises a channel.
+
+        :param client: The client (id) that sent the message.
+        :param channel: The client channel that is being advertised.
+        """
+        return None
+
+    def on_client_unadvertise(self, client: Client, client_channel_id: int) -> None:
+        """
+        Called when a client unadvertises a channel.
+
+        :param client: The client (id) that is unadvertising the channel.
+        :param client_channel_id: The client channel id that is being unadvertised.
+        """
+        return None
+
+    def on_message_data(
+        self, client: Client, client_channel_id: int, data: bytes
+    ) -> None:
+        """
+        Called when a message is received from a client.
+
+        :param client: The client (id) that sent the message.
+        :param client_channel_id: The client channel id that the message was sent on.
+        :param data: The message data.
+        """
+        return None

foxglove/layouts/__init__.py

@@ -0,0 +1,17 @@
+"""
+This module defines types for programmatically constructing Foxglove `layouts <https://docs.foxglove.dev/docs/visualization/layouts>`_.
+
+This API is currently experimental and not ready for public use.
+"""
+
+
+class Layout:
+    """A Foxglove layout
+
+    :raises NotImplementedError: This class is currently experimental and not ready for public use.
+    """
+
+    def to_json(self) -> str:
+        raise NotImplementedError(
+            "This class is currently experimental and not ready for public use."
+        )