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

viam/components/board/board.py

@@ -68,7 +68,7 @@ class Board(ComponentBase):
                 my_board = Board.from_robot(robot=machine, name="my_board")
 
                 # Get the Analog "my_example_analog_reader".
-                reader = await my_board.analog_reader_by_name(
+                reader = await my_board.analog_by_name(
                     name="my_example_analog_reader")
 
                 # Get the value of the digital signal "my_example_analog_reader" has most
@@ -366,7 +366,13 @@ class Board(ComponentBase):
 
     @abc.abstractmethod
     async def set_power_mode(
-        self, mode: PowerMode.ValueType, duration: Optional[timedelta] = None, *, timeout: Optional[float] = None, **kwargs
+        self,
+        mode: PowerMode.ValueType,
+        duration: Optional[timedelta] = None,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
     ):
         """
         Set the board to the indicated power mode.

viam/components/board/client.py

@@ -201,6 +201,7 @@ class BoardClient(Board, ReconfigurableResourceRPCClientBase):
         mode: PowerMode.ValueType,
         duration: Optional[timedelta] = None,
         *,
+        extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
         **kwargs,
     ):
@@ -208,7 +209,7 @@ class BoardClient(Board, ReconfigurableResourceRPCClientBase):
         duration_pb: Optional[Duration] = None
         if duration is not None:
             duration_pb = [(d, d.FromTimedelta(duration)) for d in [Duration()]][0][0]
-        request = SetPowerModeRequest(name=self.name, power_mode=mode, duration=duration_pb)
+        request = SetPowerModeRequest(name=self.name, power_mode=mode, duration=duration_pb, extra=dict_to_struct(extra))
         await self.client.SetPowerMode(request, timeout=timeout, metadata=md)
 
     async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[Geometry]:

viam/components/board/service.py

@@ -164,6 +164,7 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         await board.set_power_mode(
             mode=request.power_mode,
             duration=request.duration.ToTimedelta(),
+            extra=struct_to_dict(request.extra),
             timeout=timeout,
             metadata=stream.metadata,
         )

viam/components/button/__init__.py

@@ -0,0 +1,10 @@
+import viam.gen.component.button.v1.button_pb2
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .button import Button
+from .client import ButtonClient
+from .service import ButtonRPCService
+
+__all__ = ["Button"]
+
+Registry.register_api(ResourceRegistration(Button, ButtonRPCService, lambda name, channel: ButtonClient(name, channel)))

viam/components/button/button.py

@@ -0,0 +1,41 @@
+import abc
+from typing import Any, Final, Mapping, Optional
+
+from viam.components.component_base import ComponentBase
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+
+class Button(ComponentBase):
+    """
+    Button represents a device that can be pushed.
+
+    This acts as an abstract base class for any drivers representing specific
+    button implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.button import Button
+
+    For more information, see `Button component <https://docs.viam.com/dev/reference/apis/components/button/>` _.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "button"
+    )
+
+    @abc.abstractmethod
+    async def push(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> None:
+        """
+        Push the button.
+
+        ::
+
+            my_button = Button.from_robot(robot=machine, name="my_button")
+
+            # Push the button
+            await my_button.push()
+
+        For more information, see `Button component <https://docs.viam.com/dev/reference/apis/components/button/>` _.
+        """
+        ...

viam/components/button/client.py

@@ -0,0 +1,52 @@
+from typing import Any, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.gen.component.button.v1.button_pb2 import PushRequest
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.button import ButtonServiceStub
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import (
+    ValueTypes,
+    dict_to_struct,
+    struct_to_dict,
+)
+
+from .button import Button
+
+
+class ButtonClient(Button, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for Button component
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = ButtonServiceStub(channel)
+        super().__init__(name)
+
+    async def push(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> None:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = PushRequest(name=self.name, extra=dict_to_struct(extra))
+        await self.client.Push(request, timeout=timeout, metadata=md)
+
+    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/components/button/service.py

@@ -0,0 +1,46 @@
+from grpclib.server import Stream
+
+from viam.gen.component.button.v1.button_pb2 import (
+    PushRequest,
+    PushResponse,
+)
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.button import ButtonServiceBase
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .button import Button
+
+
+class ButtonRPCService(ButtonServiceBase, ResourceRPCServiceBase[Button]):
+    """
+    gRPC Service for a generic Button
+    """
+
+    RESOURCE_TYPE = Button
+
+    async def Push(self, stream: Stream[PushRequest, PushResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        button = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await button.push(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(PushResponse())
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        button = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await button.do_command(
+            command=struct_to_dict(request.command),
+            timeout=timeout,
+            metadata=stream.metadata,
+        )
+        response = DoCommandResponse(result=dict_to_struct(result))
+        await stream.send_message(response)

viam/components/camera/camera.py

@@ -1,8 +1,8 @@
 import abc
 import sys
-from typing import Any, Dict, Final, List, Optional, Tuple
+from typing import Any, Dict, Final, Optional, Sequence, Tuple
 
-from viam.media.video import NamedImage, ViamImage
+from viam.media.video import NamedImage
 from viam.proto.common import ResponseMetadata
 from viam.proto.component.camera import GetPropertiesResponse
 from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
@@ -37,33 +37,14 @@ class Camera(ComponentBase):
     Properties: "TypeAlias" = GetPropertiesResponse
 
     @abc.abstractmethod
-    async def get_image(
-        self, mime_type: str = "", *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
-    ) -> ViamImage:
-        """Get the next image from the camera as a ViamImage.
-        Be sure to close the image when finished.
-
-        NOTE: If the mime type is ``image/vnd.viam.dep`` you can use :func:`viam.media.video.ViamImage.bytes_to_depth_array`
-        to convert the data to a standard representation.
-
-        ::
-
-            my_camera = Camera.from_robot(machine, "my_camera")
-            frame = await my_camera.get_image()
-            print(f"Frame: {frame}")
-
-        Args:
-            mime_type (str): The desired mime type of the image. This does not guarantee output type
-
-        Returns:
-            ViamImage: The frame.
-
-        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getimage>`_.
-        """
-        ...
-
-    @abc.abstractmethod
-    async def get_images(self, *, timeout: Optional[float] = None, **kwargs) -> Tuple[List[NamedImage], ResponseMetadata]:
+    async def get_images(
+        self,
+        *,
+        filter_source_names: Optional[Sequence[str]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[Sequence[NamedImage], ResponseMetadata]:
         """Get simultaneous images from different imagers, along with associated metadata.
         This should not be used for getting a time series of images from the same imager.
 
@@ -75,8 +56,12 @@ class Camera(ComponentBase):
             first_image = images[0]
             timestamp = metadata.captured_at
 
+        Args:
+            filter_source_names (Sequence[str]): The filter_source_names parameter can be used to filter only the images from the specified
+                source names. When unspecified, all images are returned.
+
         Returns:
-            Tuple[List[NamedImage], ResponseMetadata]: A tuple containing two values; the first [0] a list of images
+            Tuple[Sequence[NamedImage], ResponseMetadata]: A tuple containing two values; the first [0] a list of images
             returned from the camera system, and the second [1] the metadata associated with this response.
 
         For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getimages>`_.

viam/components/camera/client.py

@@ -1,13 +1,11 @@
-from typing import Any, Dict, List, Mapping, Optional, Tuple
+from typing import Any, Dict, Mapping, Optional, Sequence, Tuple
 
 from grpclib.client import Channel
 
-from viam.media.video import CameraMimeType, NamedImage, ViamImage
+from viam.media.video import CameraMimeType, NamedImage
 from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, ResponseMetadata
 from viam.proto.component.camera import (
     CameraServiceStub,
-    GetImageRequest,
-    GetImageResponse,
     GetImagesRequest,
     GetImagesResponse,
     GetPointCloudRequest,
@@ -30,31 +28,20 @@ class CameraClient(Camera, ReconfigurableResourceRPCClientBase):
         self.client = CameraServiceStub(channel)
         super().__init__(name)
 
-    async def get_image(
-        self,
-        mime_type: str = "",
-        *,
-        extra: Optional[Dict[str, Any]] = None,
-        timeout: Optional[float] = None,
-        **kwargs,
-    ) -> ViamImage:
-        md = kwargs.get("metadata", self.Metadata()).proto
-        request = GetImageRequest(name=self.name, mime_type=mime_type, extra=dict_to_struct(extra))
-        response: GetImageResponse = await self.client.GetImage(request, timeout=timeout, metadata=md)
-        return ViamImage(response.image, CameraMimeType.from_string(response.mime_type))
-
     async def get_images(
         self,
         *,
+        filter_source_names: Optional[Sequence[str]] = None,
+        extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
         **kwargs,
-    ) -> Tuple[List[NamedImage], ResponseMetadata]:
+    ) -> Tuple[Sequence[NamedImage], ResponseMetadata]:
         md = kwargs.get("metadata", self.Metadata()).proto
-        request = GetImagesRequest(name=self.name)
+        request = GetImagesRequest(name=self.name, extra=dict_to_struct(extra), filter_source_names=filter_source_names)
         response: GetImagesResponse = await self.client.GetImages(request, timeout=timeout, metadata=md)
         imgs = []
         for img_data in response.images:
-            mime_type = CameraMimeType.from_proto(img_data.format)
+            mime_type = CameraMimeType.from_string(img_data.mime_type)
             img = NamedImage(img_data.source_name, img_data.image, mime_type)
             imgs.append(img)
         resp_metadata: ResponseMetadata = response.response_metadata
@@ -93,6 +80,8 @@ class CameraClient(Camera, ReconfigurableResourceRPCClientBase):
         response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout, metadata=md)
         return struct_to_dict(response.result)
 
-    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[Geometry]:
+    async def get_geometries(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Sequence[Geometry]:
         md = kwargs.get("metadata", self.Metadata())
         return await get_geometries(self.client, self.name, extra, timeout, md)

viam/components/camera/service.py

@@ -1,13 +1,11 @@
 # TODO: Update type checking based with RSDK-4089
 # pyright: reportGeneralTypeIssues=false
-from google.api.httpbody_pb2 import HttpBody  # type: ignore
 from grpclib.server import Stream
 
+from viam.errors import NotSupportedError
 from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
 from viam.proto.component.camera import (
     CameraServiceBase,
-    GetImageRequest,
-    GetImageResponse,
     GetImagesRequest,
     GetImagesResponse,
     GetPointCloudRequest,
@@ -15,7 +13,6 @@ from viam.proto.component.camera import (
     GetPropertiesRequest,
     GetPropertiesResponse,
     Image,
-    RenderFrameRequest,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
@@ -30,43 +27,33 @@ class CameraRPCService(CameraServiceBase, ResourceRPCServiceBase[Camera]):
 
     RESOURCE_TYPE = Camera
 
-    async def GetImage(self, stream: Stream[GetImageRequest, GetImageResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        name = request.name
-        camera = self.get_resource(name)
+    async def GetImage(self, stream: Stream) -> None:
+        """Deprecated: Use GetImages instead."""
+        raise NotSupportedError("GetImage is deprecated. Use GetImages instead.")
 
-        timeout = stream.deadline.time_remaining() if stream.deadline else None
-        image = await camera.get_image(request.mime_type, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
-        response = GetImageResponse(mime_type=image.mime_type, image=image.data)
-        await stream.send_message(response)
+    async def RenderFrame(self, stream: Stream) -> None:
+        """Deprecated: Use GetImages instead."""
+        raise NotSupportedError("RenderFrame is deprecated. Use GetImages instead.")
 
     async def GetImages(self, stream: Stream[GetImagesRequest, GetImagesResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        name = request.name
-        camera = self.get_resource(name)
+        camera = self.get_resource(request.name)
 
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        images, metadata = await camera.get_images(timeout=timeout, metadata=stream.metadata)
+        images, metadata = await camera.get_images(
+            timeout=timeout,
+            metadata=stream.metadata,
+            extra=struct_to_dict(request.extra),
+            filter_source_names=request.filter_source_names,
+        )
         img_bytes_lst = []
         for img in images:
-            fmt = img.mime_type.to_proto()
             img_bytes = img.data
-            img_bytes_lst.append(Image(source_name=name, format=fmt, image=img_bytes))
+            img_bytes_lst.append(Image(source_name=img.name, mime_type=img.mime_type, image=img_bytes))
         response = GetImagesResponse(images=img_bytes_lst, response_metadata=metadata)
         await stream.send_message(response)
 
-    async def RenderFrame(self, stream: Stream[RenderFrameRequest, HttpBody]) -> None:  # pyright: ignore [reportInvalidTypeForm]
-        request = await stream.recv_message()
-        assert request is not None
-        name = request.name
-        camera = self.get_resource(name)
-        timeout = stream.deadline.time_remaining() if stream.deadline else None
-        image = await camera.get_image(request.mime_type, timeout=timeout, metadata=stream.metadata)
-        response = HttpBody(data=image.data, content_type=image.mime_type)  # type: ignore
-        await stream.send_message(response)
-
     async def GetPointCloud(self, stream: Stream[GetPointCloudRequest, GetPointCloudResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None

viam/components/component_base.py

@@ -1,6 +1,6 @@
 import abc
 from logging import Logger
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Mapping, Optional, SupportsBytes, SupportsFloat, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Mapping, Optional, Sequence, SupportsBytes, SupportsFloat, Union, cast
 
 from typing_extensions import Self
 
@@ -46,7 +46,7 @@ class ComponentBase(abc.ABC, ResourceBase):
     async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes]:
         raise NotImplementedError()
 
-    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[Geometry]:
+    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Sequence[Geometry]:
         """
         Get all geometries associated with the component, in their current configuration, in the
         `frame <https://docs.viam.com/operate/mobility/define-geometry/>`__ of the component.

viam/components/gantry/client.py

@@ -1,8 +1,15 @@
-from typing import Any, Dict, List, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    Geometry,
+    GetKinematicsRequest,
+    GetKinematicsResponse,
+    KinematicsFileFormat,
+)
 from viam.proto.component.gantry import (
     GantryServiceStub,
     GetLengthsRequest,
@@ -110,6 +117,14 @@ class GantryClient(Gantry, ReconfigurableResourceRPCClientBase):
         response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout, metadata=md)
         return struct_to_dict(response.result)
 
+    async def get_kinematics(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetKinematicsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetKinematicsResponse = await self.client.GetKinematics(request, timeout=timeout, metadata=md)
+        return (response.format, response.kinematics_data)
+
     async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[Geometry]:
         md = kwargs.get("metadata", self.Metadata())
         return await get_geometries(self.client, self.name, extra, timeout, md)

viam/components/gantry/gantry.py

@@ -1,6 +1,7 @@
 import abc
-from typing import Any, Dict, Final, List, Optional
+from typing import Any, Dict, Final, List, Optional, Tuple
 
+from viam.components.arm import KinematicsFileFormat
 from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
 
 from ..component_base import ComponentBase
@@ -154,3 +155,33 @@ class Gantry(ComponentBase):
         For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/#ismoving>`_.
         """
         ...
+
+    @abc.abstractmethod
+    async def get_kinematics(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        """
+        Get the kinematics information associated with the gantry.
+
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            # Get the kinematics information associated with the gantry.
+            kinematics = await my_gantry.get_kinematics()
+
+            # Get the format of the kinematics file.
+            k_file = kinematics[0]
+
+            # Get the byte contents of the file.
+            k_bytes = kinematics[1]
+
+        Returns:
+            Tuple[KinematicsFileFormat.ValueType, bytes]: A tuple containing two values; the first [0] value represents the format of the
+            file, either in URDF format (``KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF``) or
+            Viam's kinematic parameter format (spatial vector algebra) (``KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA``),
+            and the second [1] value represents the byte contents of the file.
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#getkinematics>`_.
+        """
+        ...

viam/components/gantry/service.py

@@ -1,8 +1,14 @@
 from grpclib.server import Stream
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetKinematicsRequest,
+    GetKinematicsResponse,
+)
 from viam.proto.component.gantry import (
-    GantryServiceBase,
     GetLengthsRequest,
     GetLengthsResponse,
     GetPositionRequest,
@@ -15,6 +21,7 @@ from viam.proto.component.gantry import (
     MoveToPositionResponse,
     StopRequest,
     StopResponse,
+    UnimplementedGantryServiceBase,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
@@ -22,7 +29,7 @@ from viam.utils import dict_to_struct, struct_to_dict
 from .gantry import Gantry
 
 
-class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
+class GantryRPCService(UnimplementedGantryServiceBase, ResourceRPCServiceBase[Gantry]):
     """
     gRPC Service for a Gantry
     """
@@ -103,11 +110,20 @@ class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
         response = DoCommandResponse(result=dict_to_struct(result))
         await stream.send_message(response)
 
+    async def GetKinematics(self, stream: Stream[GetKinematicsRequest, GetKinematicsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        gantry = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        format, data = await gantry.get_kinematics(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetKinematicsResponse(format=format, kinematics_data=data)
+        await stream.send_message(response)
+
     async def GetGeometries(self, stream: Stream[GetGeometriesRequest, GetGeometriesResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        arm = self.get_resource(request.name)
+        gantry = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        geometries = await arm.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        geometries = await gantry.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
         response = GetGeometriesResponse(geometries=geometries)
         await stream.send_message(response)

viam/components/gripper/__init__.py

@@ -1,3 +1,4 @@
+from viam.proto.common import KinematicsFileFormat
 from viam.resource.registry import Registry, ResourceRegistration
 
 from .client import GripperClient
@@ -6,6 +7,7 @@ from .service import GripperRPCService
 
 __all__ = [
     "Gripper",
+    "KinematicsFileFormat",
 ]
 
 Registry.register_api(ResourceRegistration(Gripper, GripperRPCService, lambda name, channel: GripperClient(name, channel)))

viam/components/gripper/client.py

@@ -1,12 +1,14 @@
-from typing import Any, Dict, List, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetKinematicsRequest, GetKinematicsResponse
 from viam.proto.component.gripper import (
     GrabRequest,
     GrabResponse,
     GripperServiceStub,
+    IsHoldingSomethingRequest,
+    IsHoldingSomethingResponse,
     IsMovingRequest,
     IsMovingResponse,
     OpenRequest,
@@ -15,6 +17,7 @@ from viam.proto.component.gripper import (
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
 from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
+from . import KinematicsFileFormat
 from .gripper import Gripper
 
 
@@ -62,6 +65,14 @@ class GripperClient(Gripper, ReconfigurableResourceRPCClientBase):
         request = StopRequest(name=self.name, extra=dict_to_struct(extra))
         await self.client.Stop(request, timeout=timeout, metadata=md)
 
+    async def is_holding_something(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Gripper.HoldingStatus:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = IsHoldingSomethingRequest(name=self.name, extra=dict_to_struct(extra))
+        response: IsHoldingSomethingResponse = await self.client.IsHoldingSomething(request, timeout=timeout, metadata=md)
+        return Gripper.HoldingStatus(response.is_holding_something, meta=struct_to_dict(response.meta))
+
     async def is_moving(self, *, timeout: Optional[float] = None, **kwargs) -> bool:
         md = kwargs.get("metadata", self.Metadata()).proto
         request = IsMovingRequest(name=self.name)
@@ -83,3 +94,15 @@ class GripperClient(Gripper, ReconfigurableResourceRPCClientBase):
     async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[Geometry]:
         md = kwargs.get("metadata", self.Metadata())
         return await get_geometries(self.client, self.name, extra, timeout, md)
+
+    async def get_kinematics(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetKinematicsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetKinematicsResponse = await self.client.GetKinematics(request, timeout=timeout, metadata=md)
+        return (response.format, response.kinematics_data)