viam-sdk 0.41.1__py3-none-linux_armv6l.whl → 0.66.0__py3-none-linux_armv6l.whl

viam/services/motion/motion.py

@@ -7,7 +7,7 @@ if sys.version_info >= (3, 10):
 else:
     from typing_extensions import TypeAlias
 
-from viam.proto.common import GeoGeometry, Geometry, GeoPoint, Pose, PoseInFrame, ResourceName, Transform, WorldState
+from viam.proto.common import GeoGeometry, Geometry, GeoPoint, Pose, PoseInFrame, Transform, WorldState
 from viam.proto.service.motion import Constraints, GetPlanResponse, MotionConfiguration, PlanStatusWithID
 from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
 from viam.utils import ValueTypes
@@ -33,7 +33,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def move(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: PoseInFrame,
         world_state: Optional[WorldState] = None,
         constraints: Optional[Constraints] = None,
@@ -44,18 +44,17 @@ class Motion(ServiceBase):
         """Plan and execute a movement to move the component specified to its goal destination.
 
         Note: Frames designated with respect to components can also be used as the ``component_name`` when calling for a move. This
-        technique allows for planning and moving the frame itself to the ``destination``. To do so, simply create a resource name with
-        originating ReferenceFrame's name. Then pass in the resource name into ``component_name``. Ex::
+        technique allows for planning and moving the frame itself to the ``destination``.
+        To do so, simply pass in a string into ``component_name``. Ex::
 
-            resource_name = Arm.get_resource_name("externalFrame")
-            success = await MotionServiceClient.move(resource_name, ...)
+            success = await MotionServiceClient.move("externalFrame", ...)
 
         ::
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Assumes a gripper configured with name "my_gripper" on the machine
-            gripper_name = Gripper.get_resource_name("my_gripper")
+            # Assumes "my_gripper" on the machine
+            gripper_name = "my_gripper"
             my_frame = "my_gripper_offset"
 
             goal_pose = Pose(x=0, y=0, z=300, o_x=0, o_y=0, o_z=1, theta=0)
@@ -69,13 +68,21 @@ class Motion(ServiceBase):
                                   extra={})
 
         Args:
-            component_name (viam.proto.common.ResourceName): Name of a component on a given robot.
+            component_name (str): Name of a component on a given robot.
             destination (viam.proto.common.PoseInFrame): The destination to move to, expressed as a ``Pose`` and the frame in which it was
                 observed.
             world_state (viam.proto.common.WorldState): When supplied, the motion service will create a plan that obeys any constraints
                 expressed in the WorldState message.
             constraints (viam.proto.service.motion.Constraints): When supplied, the motion service will create a plan that obeys any
-                specified constraints.
+                specified constraints. These can include:
+                - LinearConstraint: Specifies that the component being moved should move linearly relative to its goal.
+                - OrientationConstraint: Specifies that the component being moved will not deviate its orientation beyond some threshold
+                  relative to the goal.
+                - CollisionSpecification: Used to selectively apply obstacle avoidance to specific parts of the robot.
+                - PseudolinearConstraint: Specifies that the component being moved should not deviate from the straight-line path to their
+                  goal by more than a factor proportional to the distance from start to goal. For example, if a component is moving 100mm,
+                  then a LineToleranceFactor of 1.0 means that the component will remain within a 100mm radius of the straight-line
+                  start-goal path.
 
         Returns:
             bool: Whether the move was successful.
@@ -87,9 +94,9 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def move_on_globe(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: GeoPoint,
-        movement_sensor_name: ResourceName,
+        movement_sensor_name: str,
         obstacles: Optional[Sequence[GeoGeometry]] = None,
         heading: Optional[float] = None,
         configuration: Optional[MotionConfiguration] = None,
@@ -112,24 +119,23 @@ class Motion(ServiceBase):
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Get the ResourceNames of the base and movement sensor
-            my_base_resource_name = Base.get_resource_name("my_base")
-            mvmnt_sensor_resource_name = MovementSensor.get_resource_name(
-                "my_movement_sensor")
+            # Get the names of the base and movement sensor
+            my_base_name = "my_base"
+            mvmnt_sensor_name = "my_movement_sensor"
             #  Define a destination GeoPoint at the GPS coordinates [0, 0]
             my_destination = movement_sensor.GeoPoint(latitude=0, longitude=0)
 
             # Move the base component to the designated geographic location, as reported by the movement sensor
             execution_id = await motion.move_on_globe(
-                component_name=my_base_resource_name,
+                component_name=my_base_name,
                 destination=my_destination,
-                movement_sensor_name=mvmnt_sensor_resource_name)
+                movement_sensor_name=mvmnt_sensor_name)
 
         Args:
-            component_name (ResourceName): The ResourceName of the base to move.
+            component_name (str): The name of the base to move.
             destination (GeoPoint): The location of the component's destination, represented in geographic notation as a
                 GeoPoint (lat, lng).
-            movement_sensor_name (ResourceName): The ResourceName of the movement sensor that you want to use to check
+            movement_sensor_name (str): The name of the movement sensor that you want to use to check
                 the machine's location.
             obstacles (Optional[Sequence[GeoGeometry]]): Obstacles to consider when planning the motion of the component,
                 with each represented as a GeoGeometry. Default: None
@@ -162,9 +168,9 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def move_on_map(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: Pose,
-        slam_service_name: ResourceName,
+        slam_service_name: str,
         configuration: Optional[MotionConfiguration] = None,
         obstacles: Optional[Sequence[Geometry]] = None,
         *,
@@ -186,23 +192,23 @@ class Motion(ServiceBase):
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Get the ResourceNames of the base component and SLAM service
-            my_base_resource_name = Base.get_resource_name("my_base")
-            my_slam_service_name = SLAMClient.get_resource_name("my_slam_service")
+            # Get the names of the base component and SLAM service
+            my_base_name = "my_base"
+            my_slam_service_name = "my_slam_service"
 
             # Define a destination pose with respect to the origin of the map from the SLAM service "my_slam_service"
             my_pose = Pose(y=10)
 
             # Move the base component to the destination pose of Y=10, a location of
             # (0, 10, 0) in respect to the origin of the map
-            execution_id = await motion.move_on_map(component_name=my_base_resource_name,
+            execution_id = await motion.move_on_map(component_name=my_base_name,
                                                     destination=my_pose,
                                                     slam_service_name=my_slam_service_name)
 
         Args:
-            component_name (ResourceName): The ResourceName of the base to move.
+            component_name (str): The name of the base to move.
             destination (Pose): The destination, which can be any Pose with respect to the SLAM map's origin.
-            slam_service_name (ResourceName): The ResourceName of the SLAM service from which the SLAM map is requested.
+            slam_service_name (str): The name of the SLAM service from which the SLAM map is requested.
             configuration (Optional[MotionConfiguration]): The configuration you want to set across this machine for this motion service.
                 This parameter and each of its fields are optional.
 
@@ -229,7 +235,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def stop_plan(
         self,
-        component_name: ResourceName,
+        component_name: str,
         *,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
@@ -243,11 +249,11 @@ class Motion(ServiceBase):
             # Assuming a `move_on_globe()` started the execution
             # Stop the base component which was instructed to move by `move_on_globe()`
             # or `move_on_map()`
-            my_base_resource_name = Base.get_resource_name("my_base")
+            my_base_name = "my_base"
             await motion.stop_plan(component_name=mvmnt_sensor)
 
         Args:
-            component_name (ResourceName): The component to stop
+            component_name (str): The component to stop
 
         For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#stopplan>`_.
         """
@@ -256,7 +262,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def get_plan(
         self,
-        component_name: ResourceName,
+        component_name: str,
         last_plan_only: bool = False,
         execution_id: Optional[str] = None,
         *,
@@ -283,12 +289,12 @@ class Motion(ServiceBase):
         ::
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
-            my_base_resource_name = Base.get_resource_name("my_base")
+            my_base_name = "my_base"
             # Get the plan(s) of the base component which was instructed to move by `MoveOnGlobe()` or `MoveOnMap()`
-            resp = await motion.get_plan(component_name=my_base_resource_name)
+            resp = await motion.get_plan(component_name=my_base_name)
 
         Args:
-            component_name (ResourceName): The component to stop
+            component_name (str): The component to stop
             last_plan_only (Optional[bool]): If supplied, the response will only return the last plan for the component / execution.
             execution_id (Optional[str]): If supplied, the response will only return plans with the provided execution_id.
 
@@ -335,7 +341,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def get_pose(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination_frame: str,
         supplemental_transforms: Optional[Sequence[Transform]] = None,
         *,
@@ -347,25 +353,21 @@ class Motion(ServiceBase):
 
         ::
 
-            # Note that the example uses the ``Arm`` class, but any component class that inherits from ``ComponentBase`` will work
-            # (``Base``, ``Gripper``, etc).
-
-            # Create a `component_name`:
-            component_name = Arm.get_resource_name("arm")
+            # Note that the example uses the ``Gripper`` class, but any component class that inherits from ``ComponentBase`` will work
+            # (``Arm``, ``Base``, etc).
 
             from viam.components.gripper import Gripper
             from viam.services.motion import MotionClient
 
             # Assume that the connect function is written and will return a valid machine.
-            robot = await connect()
+            machine = await connect()
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
-            gripperName = Gripper.get_resource_name("my_gripper")
-            gripperPoseInWorld = await motion.get_pose(component_name=gripperName,
-                                                    destination_frame="world")
+            gripperPoseInWorld = await motion.get_pose(component_name="my_gripper",
+                                                       destination_frame="world")
 
         Args:
-            component_name (viam.proto.common.ResourceName): Name of a component on a robot.
+            component_name (str): Name of a component on a robot.
             destination_frame (str): Name of the desired reference frame.
             supplemental_transforms (Optional[List[viam.proto.common.Transform]]): Transforms used to augment the robot's frame while
                 calculating pose.

viam/services/navigation/navigation.py

@@ -141,8 +141,8 @@ class Navigation(ServiceBase):
             await my_nav.add_waypoint(point=location)
 
         Args:
-            point (navigation.GeoPoint): The current location of the robot in the navigation service,
-                represented in a GeoPoint with latitude and longitude values.
+            point (navigation.GeoPoint): A waypoint represented in a GeoPoint with
+                latitude and longitude values.
             timeout (Optional[float]): An option to set how long to wait (in seconds)
                 before calling a time-out and closing the underlying RPC call.
 

viam/services/vision/client.py

@@ -69,7 +69,7 @@ class VisionClient(Vision, ReconfigurableResourceRPCClientBase):
         result = CaptureAllResult()
         result.extra = struct_to_dict(response.extra)
         if return_image:
-            mime_type = CameraMimeType.from_proto(response.image.format)
+            mime_type = CameraMimeType.from_string(response.image.mime_type)
             img = ViamImage(response.image.image, mime_type)
             result.image = img
         if return_classifications:

viam/services/vision/service.py

@@ -26,7 +26,7 @@ from viam.utils import dict_to_struct, struct_to_dict
 from .vision import Vision
 
 
-class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase):
+class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase[Vision]):
     """
     gRPC service for a Vision service
     """
@@ -50,9 +50,8 @@ class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase):
         )
         img = None
         if result.image is not None:
-            fmt = result.image.mime_type.to_proto()
             img_bytes = result.image.data
-            img = Image(source_name=request.camera_name, format=fmt, image=img_bytes)
+            img = Image(source_name=request.camera_name, mime_type=result.image.mime_type, image=img_bytes)
         response = CaptureAllFromCameraResponse(
             image=img,
             detections=result.detections,
@@ -79,8 +78,7 @@ class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase):
         extra = struct_to_dict(request.extra)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
 
-        mime_type = CameraMimeType.from_string(request.mime_type)
-        image = ViamImage(request.image, mime_type)
+        image = ViamImage(request.image, CameraMimeType.from_string(request.mime_type))
 
         result = await vision.get_detections(image, extra=extra, timeout=timeout)
         response = GetDetectionsResponse(detections=result)
@@ -105,8 +103,7 @@ class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase):
         extra = struct_to_dict(request.extra)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
 
-        mime_type = CameraMimeType.from_string(request.mime_type)
-        image = ViamImage(request.image, mime_type)
+        image = ViamImage(request.image, CameraMimeType.from_string(request.mime_type))
 
         result = await vision.get_classifications(image, request.n, extra=extra, timeout=timeout)
         response = GetClassificationsResponse(classifications=result)
@@ -119,7 +116,7 @@ class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase):
         extra = struct_to_dict(request.extra)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await vision.get_object_point_clouds(request.camera_name, extra=extra, timeout=timeout)
-        response = GetObjectPointCloudsResponse(mime_type=CameraMimeType.PCD.value, objects=result)
+        response = GetObjectPointCloudsResponse(mime_type=CameraMimeType.PCD, objects=result)
         await stream.send_message(response)
 
     async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:

viam/services/vision/vision.py

@@ -36,7 +36,7 @@ class CaptureAllResult:
     ):
         """
         Args:
-            image (ViamImage|None): The image from the GetImage request of the camera, if it was requested.
+            image (ViamImage|None): The image from the GetImages request of the camera, if it was requested.
             classifications (List[Classification]|None): The classifications from GetClassifications, if it was requested.
             detections (List[Detection]|None): The detections from GetDetections, if it was requested.
             objects (List[PointCloudObject]|None): the object point clouds from GetObjectPointClouds, if it was requested.
@@ -168,7 +168,8 @@ class Vision(ServiceBase):
             my_detector = VisionClient.from_robot(robot=machine, "my_detector")
 
             # Get an image from the camera
-            img = await my_camera.get_image()
+            images, _ = await my_camera.get_images()
+            img = images[0]
 
             # Get detections for that image
             detections = await my_detector.get_detections(img)
@@ -235,7 +236,8 @@ class Vision(ServiceBase):
             my_classifier = VisionClient.from_robot(robot=machine, "my_classifier")
 
             # Get an image from the camera
-            img = await my_camera.get_image()
+            images, _ = await my_camera.get_images()
+            img = images[0]
 
             # Get the 2 classifications with the highest confidence scores for the image
             classifications = await my_classifier.get_classifications(img, 2)

viam/services/worldstatestore/__init__.py

@@ -0,0 +1,18 @@
+from viam.proto.service.worldstatestore import StreamTransformChangesResponse, TransformChangeType
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import WorldStateStoreClient
+from .service import WorldStateStoreService
+from .worldstatestore import WorldStateStore
+
+__all__ = [
+    "WorldStateStore",
+    "WorldStateStoreClient",
+    "WorldStateStoreService",
+    "StreamTransformChangesResponse",
+    "TransformChangeType",
+]
+
+Registry.register_api(
+    ResourceRegistration(WorldStateStore, WorldStateStoreService, lambda name, channel: WorldStateStoreClient(name, channel))
+)

viam/services/worldstatestore/client.py

@@ -0,0 +1,94 @@
+from typing import Any, AsyncGenerator, List, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Transform
+from viam.proto.service.worldstatestore import (
+    GetTransformRequest,
+    GetTransformResponse,
+    ListUUIDsRequest,
+    ListUUIDsResponse,
+    StreamTransformChangesRequest,
+    StreamTransformChangesResponse,
+    WorldStateStoreServiceStub,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+
+from .worldstatestore import WorldStateStore
+
+
+class WorldStateStoreClient(WorldStateStore, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the WorldStateStore service.
+    """
+
+    client: WorldStateStoreServiceStub
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = WorldStateStoreServiceStub(channel)
+        super().__init__(name)
+
+    async def list_uuids(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> List[bytes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = ListUUIDsRequest(
+            name=self.name,
+            extra=dict_to_struct(extra),
+        )
+        response: ListUUIDsResponse = await self.client.ListUUIDs(request, timeout=timeout, metadata=md)
+        return list(response.uuids)
+
+    async def get_transform(
+        self,
+        uuid: bytes,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> "Transform":
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetTransformRequest(
+            name=self.name,
+            uuid=uuid,
+            extra=dict_to_struct(extra),
+        )
+        response: GetTransformResponse = await self.client.GetTransform(request, timeout=timeout, metadata=md)
+        return response.transform
+
+    async def stream_transform_changes(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> AsyncGenerator[StreamTransformChangesResponse, None]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = StreamTransformChangesRequest(
+            name=self.name,
+            extra=dict_to_struct(extra),
+        )
+        responses = await self.client.StreamTransformChanges(request, timeout=timeout, metadata=md)
+        for response in responses:
+            yield response
+
+    async def do_command(
+        self,
+        command: Mapping[str, ValueTypes],
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, ValueTypes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = DoCommandRequest(
+            name=self.name,
+            command=dict_to_struct(command),
+        )
+        response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout, metadata=md)
+        return struct_to_dict(response.result)

viam/services/worldstatestore/service.py

@@ -0,0 +1,55 @@
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.service.worldstatestore import (
+    GetTransformRequest,
+    GetTransformResponse,
+    ListUUIDsRequest,
+    ListUUIDsResponse,
+    StreamTransformChangesRequest,
+    StreamTransformChangesResponse,
+    UnimplementedWorldStateStoreServiceBase,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .worldstatestore import WorldStateStore
+
+
+class WorldStateStoreService(UnimplementedWorldStateStoreServiceBase, ResourceRPCServiceBase[WorldStateStore]):
+    RESOURCE_TYPE = WorldStateStore
+
+    async def ListUUIDs(self, stream: Stream[ListUUIDsRequest, ListUUIDsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        uuids = await service.list_uuids(extra=struct_to_dict(request.extra), timeout=timeout)
+        await stream.send_message(ListUUIDsResponse(uuids=uuids))
+
+    async def GetTransform(self, stream: Stream[GetTransformRequest, GetTransformResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        transform = await service.get_transform(uuid=request.uuid, extra=struct_to_dict(request.extra), timeout=timeout)
+        await stream.send_message(GetTransformResponse(transform=transform))
+
+    async def StreamTransformChanges(
+        self,
+        stream: Stream[StreamTransformChangesRequest, StreamTransformChangesResponse],
+    ) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        async for change in service.stream_transform_changes(extra=struct_to_dict(request.extra), timeout=timeout):
+            await stream.send_message(change)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        worldstatestore = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await worldstatestore.do_command(struct_to_dict(request.command), timeout=timeout)
+        await stream.send_message(DoCommandResponse(result=dict_to_struct(result)))

viam/services/worldstatestore/worldstatestore.py

@@ -0,0 +1,90 @@
+import abc
+from typing import Any, AsyncGenerator, Final, List, Mapping, Optional
+
+from viam.proto.common import Transform
+from viam.proto.service.worldstatestore import (
+    StreamTransformChangesResponse,
+)
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
+
+from ..service_base import ServiceBase
+
+
+class WorldStateStore(ServiceBase):
+    """WorldStateStore is a Viam service that manages world state transforms.
+
+    The WorldStateStore service provides functionality to store, retrieve, and stream
+    changes to world state transforms, which represent the pose of objects in different
+    reference frames. This functionality can be used to create custom visualizations of the world state.
+
+    For more information, see `WorldStateStore service <https://docs.viam.com/dev/reference/apis/services/world-state-store/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "world_state_store"
+    )
+
+    @abc.abstractmethod
+    async def list_uuids(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> List[bytes]:
+        """List all world state transform UUIDs.
+
+        ::
+
+            worldstatestore = WorldStateStoreClient.from_robot(robot=machine, name="builtin")
+
+            uuids = await worldstatestore.list_uuids()
+
+        Returns:
+            List[bytes]: A list of transform UUIDs
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_transform(
+        self,
+        uuid: bytes,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> Transform:
+        """Get a world state transform by UUID.
+
+        ::
+
+            worldstatestore = WorldStateStoreClient.from_robot(robot=machine, name="builtin")
+
+            transform = await worldstatestore.get_transform(uuid=b"some-uuid")
+
+        Args:
+            uuid (bytes): The UUID of the transform to retrieve
+
+        Returns:
+            Transform: The requested transform
+        """
+        ...
+
+    @abc.abstractmethod
+    async def stream_transform_changes(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> AsyncGenerator[StreamTransformChangesResponse, None]:
+        """Stream changes to world state transforms.
+
+        ::
+
+            worldstatestore = WorldStateStoreClient.from_robot(robot=machine, name="builtin")
+
+            async for change in worldstatestore.stream_transform_changes():
+                print(f"Transform {change.transform.uuid} {change.change_type}")
+
+        Returns:
+            AsyncGenerator[StreamTransformChangesResponse, None]: A stream of transform changes
+        """
+        ...