viam-sdk 0.54.2b0__py3-none-linux_armv6l.whl → 0.55.0__py3-none-linux_armv6l.whl

viam/gen/stream/v1/stream_pb2.py

@@ -4,7 +4,7 @@ from google.protobuf import descriptor_pool as _descriptor_pool
 from google.protobuf import runtime_version as _runtime_version
 from google.protobuf import symbol_database as _symbol_database
 from google.protobuf.internal import builder as _builder
-_runtime_version.ValidateProtobufRuntimeVersion(_runtime_version.Domain.PUBLIC, 5, 29, 2, '', 'stream/v1/stream.proto')
+_runtime_version.ValidateProtobufRuntimeVersion(_runtime_version.Domain.PUBLIC, 5, 29, 3, '', 'stream/v1/stream.proto')
 _sym_db = _symbol_database.Default()
 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16stream/v1/stream.proto\x12\x0fproto.stream.v1"\x14\n\x12ListStreamsRequest"+\n\x13ListStreamsResponse\x12\x14\n\x05names\x18\x01 \x03(\tR\x05names"&\n\x10AddStreamRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name"\x13\n\x11AddStreamResponse")\n\x13RemoveStreamRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name"\x16\n\x14RemoveStreamResponse":\n\nResolution\x12\x14\n\x05width\x18\x01 \x01(\x05R\x05width\x12\x16\n\x06height\x18\x02 \x01(\x05R\x06height"-\n\x17GetStreamOptionsRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name"Y\n\x18GetStreamOptionsResponse\x12=\n\x0bresolutions\x18\x01 \x03(\x0b2\x1b.proto.stream.v1.ResolutionR\x0bresolutions"j\n\x17SetStreamOptionsRequest\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12;\n\nresolution\x18\x02 \x01(\x0b2\x1b.proto.stream.v1.ResolutionR\nresolution"\x1a\n\x18SetStreamOptionsResponse2\xec\x03\n\rStreamService\x12X\n\x0bListStreams\x12#.proto.stream.v1.ListStreamsRequest\x1a$.proto.stream.v1.ListStreamsResponse\x12R\n\tAddStream\x12!.proto.stream.v1.AddStreamRequest\x1a".proto.stream.v1.AddStreamResponse\x12g\n\x10GetStreamOptions\x12(.proto.stream.v1.GetStreamOptionsRequest\x1a).proto.stream.v1.GetStreamOptionsResponse\x12g\n\x10SetStreamOptions\x12(.proto.stream.v1.SetStreamOptionsRequest\x1a).proto.stream.v1.SetStreamOptionsResponse\x12[\n\x0cRemoveStream\x12$.proto.stream.v1.RemoveStreamRequest\x1a%.proto.stream.v1.RemoveStreamResponseB.Z,github.com/edaniels/gostream/proto/stream/v1b\x06proto3')
 _globals = globals()

viam/gen/tagger/v1/tagger_pb2.py

@@ -4,7 +4,7 @@ from google.protobuf import descriptor_pool as _descriptor_pool
 from google.protobuf import runtime_version as _runtime_version
 from google.protobuf import symbol_database as _symbol_database
 from google.protobuf.internal import builder as _builder
-_runtime_version.ValidateProtobufRuntimeVersion(_runtime_version.Domain.PUBLIC, 5, 29, 2, '', 'tagger/v1/tagger.proto')
+_runtime_version.ValidateProtobufRuntimeVersion(_runtime_version.Domain.PUBLIC, 5, 29, 3, '', 'tagger/v1/tagger.proto')
 _sym_db = _symbol_database.Default()
 from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2
 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16tagger/v1/tagger.proto\x12\ttagger.v1\x1a google/protobuf/descriptor.proto:3\n\x04tags\x12\x1d.google.protobuf.FieldOptions\x18\xc3\xe03 \x01(\tR\x04tags:>\n\noneof_tags\x12\x1d.google.protobuf.OneofOptions\x18\xc3\xe03 \x01(\tR\toneofTagsB4Z2github.com/srikrsna/protoc-gen-gotag/tagger;taggerb\x06proto3')

viam/media/utils/pil/__init__.py

@@ -39,6 +39,10 @@ def pil_to_viam_image(image: Image.Image, mime_type: CameraMimeType) -> ViamImag
     Returns:
         ViamImage: The resulting ViamImage
     """
+    # Make sure at runtime the mime_type string is actually a CameraMimeType
+    if not isinstance(mime_type, CameraMimeType):
+        raise ValueError(f"Cannot encode to unsupported mimetype: {mime_type}")
+
     if mime_type.name in LIBRARY_SUPPORTED_FORMATS:
         buf = BytesIO()
         if image.mode == "RGBA" and mime_type == CameraMimeType.JPEG:
@@ -46,6 +50,6 @@ def pil_to_viam_image(image: Image.Image, mime_type: CameraMimeType) -> ViamImag
         image.save(buf, format=mime_type.name)
         data = buf.getvalue()
     else:
-        raise ValueError(f"Cannot encode image to {mime_type}")
+        raise ValueError(f"Cannot encode to unsupported mimetype: {mime_type}")
 
     return ViamImage(data, mime_type)

viam/media/video.py

@@ -1,8 +1,7 @@
 from array import array
-from enum import Enum
-from typing import List, Optional, Tuple
+from typing import Any, List, Optional, Tuple
 
-from typing_extensions import Self
+from typing_extensions import ClassVar, Self
 
 from viam.errors import NotSupportedError
 from viam.proto.component.camera import Format
@@ -10,12 +9,53 @@ from viam.proto.component.camera import Format
 from .viam_rgba import RGBA_HEADER_LENGTH, RGBA_MAGIC_NUMBER
 
 
-class CameraMimeType(str, Enum):
-    VIAM_RGBA = "image/vnd.viam.rgba"
-    VIAM_RAW_DEPTH = "image/vnd.viam.dep"
-    JPEG = "image/jpeg"
-    PNG = "image/png"
-    PCD = "pointcloud/pcd"
+class _FrozenClassAttributesMeta(type):
+    """
+    A metaclass that prevents the reassignment of existing class attributes.
+    """
+
+    def __setattr__(cls, name: str, value: Any):
+        # Check if the attribute `name` already exists on the class
+        if name in cls.__dict__:
+            # If it exists, raise an error to prevent overwriting
+            raise AttributeError(f"Cannot reassign constant '{name}'")
+        # If it's a new attribute, allow it to be set
+        super().__setattr__(name, value)
+
+
+class CameraMimeType(str, metaclass=_FrozenClassAttributesMeta):
+    """
+    The compatible mime-types for cameras and vision services.
+
+    You can use the `CameraMimeType.CUSTOM(...)` method to use an unlisted mime-type.
+    """
+
+    VIAM_RGBA: ClassVar[Self]
+    VIAM_RAW_DEPTH: ClassVar[Self]
+    JPEG: ClassVar[Self]
+    PNG: ClassVar[Self]
+    PCD: ClassVar[Self]
+
+    @property
+    def name(self) -> str:
+        for key, value in self.__class__.__dict__.items():
+            if value == self:
+                return key
+        return "CUSTOM"
+
+    @property
+    def value(self) -> str:
+        return self
+
+    @classmethod
+    def CUSTOM(cls, mime_type: str) -> Self:
+        """
+        Create a custom mime type.
+
+        Args:
+            mime_type (str): The mimetype as a string
+        """
+        return cls.from_string(mime_type)
 
     @classmethod
     def from_string(cls, value: str) -> Self:
@@ -31,7 +71,7 @@ class CameraMimeType(str, Enum):
         return cls(value_mime)
 
     @classmethod
-    def from_proto(cls, format: Format.ValueType) -> "CameraMimeType":
+    def from_proto(cls, format: Format.ValueType) -> Self:
         """Returns the mimetype from a proto enum.
 
         Args:
@@ -41,14 +81,15 @@ class CameraMimeType(str, Enum):
             Self: The mimetype.
         """
         mimetypes = {
-            Format.FORMAT_RAW_RGBA: CameraMimeType.VIAM_RGBA,
-            Format.FORMAT_RAW_DEPTH: CameraMimeType.VIAM_RAW_DEPTH,
-            Format.FORMAT_JPEG: CameraMimeType.JPEG,
-            Format.FORMAT_PNG: CameraMimeType.PNG,
+            Format.FORMAT_RAW_RGBA: cls.VIAM_RGBA,
+            Format.FORMAT_RAW_DEPTH: cls.VIAM_RAW_DEPTH,
+            Format.FORMAT_JPEG: cls.JPEG,
+            Format.FORMAT_PNG: cls.PNG,
         }
-        return mimetypes.get(format, CameraMimeType.JPEG)
+        return cls(mimetypes.get(format, cls.JPEG))
 
-    def to_proto(self) -> Format.ValueType:
+    @property
+    def proto(self) -> Format.ValueType:
         """Returns the mimetype in a proto enum.
 
         Returns:
@@ -62,6 +103,19 @@ class CameraMimeType(str, Enum):
         }
         return formats.get(self, Format.FORMAT_UNSPECIFIED)
 
+    def to_proto(self) -> Format.ValueType:
+        """
+        DEPRECATED: Use `CameraMimeType.proto`
+        """
+        return self.proto
+
+
+CameraMimeType.VIAM_RGBA = CameraMimeType.from_string("image/vnd.viam.rgba")
+CameraMimeType.VIAM_RAW_DEPTH = CameraMimeType.from_string("image/vnd.viam.dep")
+CameraMimeType.JPEG = CameraMimeType.from_string("image/jpeg")
+CameraMimeType.PNG = CameraMimeType.from_string("image/png")
+CameraMimeType.PCD = CameraMimeType.from_string("pointcloud/pcd")
+
 
 class ViamImage:
     """A native implementation of an image.

viam/proto/common/__init__.py

@@ -22,6 +22,7 @@ from ...gen.common.v1.common_pb2 import (
     LogEntry,
     Mesh,
     Orientation,
+    PointCloud,
     PointCloudObject,
     Pose,
     PoseInFrame,
@@ -53,6 +54,7 @@ __all__ = [
     "LogEntry",
     "Mesh",
     "Orientation",
+    "PointCloud",
     "PointCloudObject",
     "Pose",
     "PoseInFrame",

viam/proto/service/worldstatestore/__init__.py

@@ -0,0 +1,32 @@
+"""
+@generated by Viam.
+Do not edit manually!
+"""
+
+from ....gen.service.worldstatestore.v1.world_state_store_grpc import (
+    UnimplementedWorldStateStoreServiceBase,
+    WorldStateStoreServiceBase,
+    WorldStateStoreServiceStub,
+)
+from ....gen.service.worldstatestore.v1.world_state_store_pb2 import (
+    GetTransformRequest,
+    GetTransformResponse,
+    ListUUIDsRequest,
+    ListUUIDsResponse,
+    StreamTransformChangesRequest,
+    StreamTransformChangesResponse,
+    TransformChangeType,
+)
+
+__all__ = [
+    "UnimplementedWorldStateStoreServiceBase",
+    "WorldStateStoreServiceBase",
+    "WorldStateStoreServiceStub",
+    "GetTransformRequest",
+    "GetTransformResponse",
+    "ListUUIDsRequest",
+    "ListUUIDsResponse",
+    "StreamTransformChangesRequest",
+    "StreamTransformChangesResponse",
+    "TransformChangeType",
+]

viam/services/vision/client.py

@@ -69,7 +69,11 @@ class VisionClient(Vision, ReconfigurableResourceRPCClientBase):
         result = CaptureAllResult()
         result.extra = struct_to_dict(response.extra)
         if return_image:
-            mime_type = CameraMimeType.from_proto(response.image.format)
+            # TODO(RSDK-11728): remove this branching logic once we deleted the format field
+            if response.image.mime_type:
+                mime_type = CameraMimeType.from_string(response.image.mime_type)
+            else:
+                mime_type = CameraMimeType.from_proto(response.image.format)
             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,11 @@ class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase):
         )
         img = None
         if result.image is not None:
-            fmt = result.image.mime_type.to_proto()
+            mime_type = CameraMimeType.from_string(result.image.mime_type)
+            # TODO(RSDK-11728): remove this fmt logic once we deleted the format field
+            fmt = mime_type.to_proto()  # Will be Format.FORMAT_UNSPECIFIED if an unsupported/custom mime type is set
             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=mime_type, format=fmt, image=img_bytes)
         response = CaptureAllFromCameraResponse(
             image=img,
             detections=result.detections,
@@ -79,8 +81,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 +106,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 +119,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/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/worldstatestore/>`_.
+    """
+
+    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:
+            AsyncIterator[StreamTransformChangesResponse]: A stream of transform changes
+        """
+        ...

viam/version_metadata.py

@@ -1,4 +1,4 @@
-__version__ = "0.54.2b0"
+__version__ = "0.55.0"
 
-API_VERSION = "v0.1.474"
+API_VERSION = "v0.1.475"
 SDK_VERSION = __version__

{viam_sdk-0.54.2b0.dist-info → viam_sdk-0.55.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viam-sdk
-Version: 0.54.2b0
+Version: 0.55.0
 Summary: Viam Robotics Python SDK
 Project-URL: Homepage, https://www.viam.com
 Project-URL: Documentation, https://python.viam.dev