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

viam/components/camera/__init__.py

@@ -1,4 +1,4 @@
-from viam.media.video import RawImage
+from viam.media.video import ViamImage
 from viam.proto.component.camera import DistortionParameters, IntrinsicParameters
 from viam.resource.registry import Registry, ResourceRegistration
 
@@ -10,10 +10,10 @@ __all__ = [
     "Camera",
     "IntrinsicParameters",
     "DistortionParameters",
-    "RawImage",
+    "ViamImage",
 ]
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         Camera,
         CameraRPCService,

viam/components/camera/camera.py

@@ -1,12 +1,18 @@
 import abc
-from typing import Final, NamedTuple, Optional, Tuple, Union
+import sys
+from typing import Any, Dict, Final, Optional, Sequence, Tuple
 
-from PIL.Image import Image
-
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+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
 
 from ..component_base import ComponentBase
-from . import DistortionParameters, IntrinsicParameters, RawImage
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
 
 
 class Camera(ComponentBase):
@@ -16,40 +22,56 @@ class Camera(ComponentBase):
     This acts as an abstract base class for any drivers representing specific
     camera implementations. This cannot be used on its own. If the ``__init__()`` function is
     overridden, it must call the ``super().__init__()`` function.
-    """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "camera")
+    ::
 
-    class Properties(NamedTuple):
-        """The camera's supported features and settings"""
+        from viam.components.camera import Camera
 
-        supports_pcd: bool
-        """Whether the camera has a valid implementation of ``get_point_cloud``"""
+    For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/>`_.
+    """
 
-        intrinsic_parameters: IntrinsicParameters
-        """The properties of the camera"""
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "camera"
+    )
 
-        distortion_parameters: DistortionParameters
-        """The distortion parameters of the camera"""
+    Properties: "TypeAlias" = GetPropertiesResponse
 
     @abc.abstractmethod
-    async def get_image(self, mime_type: str = "", *, timeout: Optional[float] = None, **kwargs) -> Union[Image, RawImage]:
-        """Get the next image from the camera as an Image or RawImage.
-        Be sure to close the image when finished.
+    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.
 
-        NOTE: If the mime type is ``image/vnd.viam.dep`` you can use :func:`viam.media.video.RawImage.bytes_to_depth_array`
-        to convert the data to a standard representation.
+        ::
+
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
+
+            images, metadata = await my_camera.get_images()
+            first_image = images[0]
+            timestamp = metadata.captured_at
 
         Args:
-            mime_type (str): The desired mime type of the image. This does not guarantee output type
+            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:
-            Image | RawImage: The frame
+            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>`_.
         """
         ...
 
     @abc.abstractmethod
-    async def get_point_cloud(self, *, timeout: Optional[float] = None, **kwargs) -> Tuple[bytes, str]:
+    async def get_point_cloud(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Tuple[bytes, str]:
         """
         Get the next point cloud from the camera. This will be
         returned as bytes with a mimetype describing
@@ -58,12 +80,15 @@ class Camera(ComponentBase):
         by the mimetype.
 
         To deserialize the returned information into a numpy array, use the Open3D library.
+
         ::
 
             import numpy as np
             import open3d as o3d
 
-            data, _ = await camera.get_point_cloud()
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
+
+            data, _ = await my_camera.get_point_cloud()
 
             # write the point cloud into a temporary file
             with open("/tmp/pointcloud_data.pcd", "wb") as f:
@@ -72,8 +97,10 @@ class Camera(ComponentBase):
             points = np.asarray(pcd.points)
 
         Returns:
-            bytes: The pointcloud data.
-            str: The mimetype of the pointcloud (e.g. PCD).
+            Tuple[bytes, str]: A tuple containing two values; the first [0] the pointcloud data,
+            and the second [1] the mimetype of the pointcloud (for example, PCD).
+
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getpointcloud>`_.
         """
         ...
 
@@ -82,7 +109,15 @@ class Camera(ComponentBase):
         """
         Get the camera intrinsic parameters and camera distortion parameters
 
+        ::
+
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
+
+            properties = await my_camera.get_properties()
+
         Returns:
-            Properties: The properties of the camera
+            Properties: The properties of the camera.
+
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getproperties>`_.
         """
         ...

viam/components/camera/client.py

@@ -1,24 +1,21 @@
-from io import BytesIO
-from typing import Mapping, Optional, Tuple, Union
+from typing import Any, Dict, Mapping, Optional, Sequence, Tuple
 
 from grpclib.client import Channel
-from PIL import Image
 
-from viam.media.video import LIBRARY_SUPPORTED_FORMATS, CameraMimeType
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+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,
     GetPointCloudResponse,
     GetPropertiesRequest,
-    GetPropertiesResponse,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
-from . import Camera, RawImage
+from . import Camera
 
 
 class CameraClient(Camera, ReconfigurableResourceRPCClientBase):
@@ -31,25 +28,60 @@ class CameraClient(Camera, ReconfigurableResourceRPCClientBase):
         self.client = CameraServiceStub(channel)
         super().__init__(name)
 
-    async def get_image(self, mime_type: str = "", *, timeout: Optional[float] = None) -> Union[Image.Image, RawImage]:
-        request = GetImageRequest(name=self.name, mime_type=mime_type)
-        response: GetImageResponse = await self.client.GetImage(request, timeout=timeout)
-        _, is_lazy = CameraMimeType.from_lazy(request.mime_type)
-        if is_lazy or not (CameraMimeType.is_supported(response.mime_type)):
-            image = RawImage(response.image, response.mime_type)
-            return image
-        return Image.open(BytesIO(response.image), formats=LIBRARY_SUPPORTED_FORMATS)
-
-    async def get_point_cloud(self, *, timeout: Optional[float] = None) -> Tuple[bytes, str]:
-        request = GetPointCloudRequest(name=self.name, mime_type=CameraMimeType.PCD)
-        response: GetPointCloudResponse = await self.client.GetPointCloud(request, timeout=timeout)
+    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]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        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_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
+        return imgs, resp_metadata
+
+    async def get_point_cloud(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[bytes, str]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPointCloudRequest(name=self.name, mime_type=CameraMimeType.PCD, extra=dict_to_struct(extra))
+        response: GetPointCloudResponse = await self.client.GetPointCloud(request, timeout=timeout, metadata=md)
         return (response.point_cloud, response.mime_type)
 
-    async def get_properties(self, *, timeout: Optional[float] = None) -> Camera.Properties:
-        response: GetPropertiesResponse = await self.client.GetProperties(GetPropertiesRequest(name=self.name), timeout=timeout)
-        return Camera.Properties(response.supports_pcd, response.intrinsic_parameters, response.distortion_parameters)
+    async def get_properties(
+        self,
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Camera.Properties:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        return await self.client.GetProperties(GetPropertiesRequest(name=self.name), timeout=timeout, metadata=md)
 
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None) -> Mapping[str, ValueTypes]:
+    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)
+        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
+    ) -> 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,23 +1,23 @@
-from google.api.httpbody_pb2 import HttpBody
+# TODO: Update type checking based with RSDK-4089
+# pyright: reportGeneralTypeIssues=false
 from grpclib.server import Stream
 
-from viam.errors import ResourceNotFoundError
-from viam.media.video import CameraMimeType
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+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,
     GetPointCloudResponse,
     GetPropertiesRequest,
     GetPropertiesResponse,
-    RenderFrameRequest,
+    Image,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
 
-from . import Camera, RawImage
+from . import Camera
 
 
 class CameraRPCService(CameraServiceBase, ResourceRPCServiceBase[Camera]):
@@ -27,61 +27,40 @@ 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
-        try:
-            camera = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+    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, timeout=timeout, metadata=stream.metadata)
-        try:
-            mimetype, is_lazy = CameraMimeType.from_lazy(request.mime_type)
-            if CameraMimeType.is_supported(mimetype):
-                response_mime = mimetype
-            else:
-                response_mime = request.mime_type
-            response = GetImageResponse(mime_type=response_mime)
-            img_bytes = mimetype.encode_image(image)
-        finally:
-            image.close()
-        response.image = img_bytes
-        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 RenderFrame(self, stream: Stream[RenderFrameRequest, HttpBody]) -> None:
+    async def GetImages(self, stream: Stream[GetImagesRequest, GetImagesResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        name = request.name
-        try:
-            camera = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
-        try:
-            mimetype = CameraMimeType(request.mime_type)
-        except ValueError:
-            mimetype = CameraMimeType.JPEG
+        camera = self.get_resource(request.name)
+
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        image = await camera.get_image(mimetype, timeout=timeout, metadata=stream.metadata)
-        try:
-            img = mimetype.encode_image(image)
-        finally:
-            image.close()
-        response = HttpBody(data=img, content_type=image.mime_type if isinstance(image, RawImage) else mimetype)
+        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:
+            img_bytes = img.data
+            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 GetPointCloud(self, stream: Stream[GetPointCloudRequest, GetPointCloudResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            camera = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        camera = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        pc, mimetype = await camera.get_point_cloud(timeout=timeout, metadata=stream.metadata)
+        pc, mimetype = await camera.get_point_cloud(timeout=timeout, extra=struct_to_dict(request.extra), metadata=stream.metadata)
         response = GetPointCloudResponse(mime_type=mimetype, point_cloud=pc)
         await stream.send_message(response)
 
@@ -89,27 +68,25 @@ class CameraRPCService(CameraServiceBase, ResourceRPCServiceBase[Camera]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            camera = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        camera = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         properties = await camera.get_properties(timeout=timeout, metadata=stream.metadata)
-        response = GetPropertiesResponse(
-            supports_pcd=properties.supports_pcd,
-            intrinsic_parameters=properties.intrinsic_parameters,
-            distortion_parameters=properties.distortion_parameters,
-        )
-        await stream.send_message(response)
+        await stream.send_message(properties)
 
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            camera = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        camera = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await camera.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)
+
+    async def GetGeometries(self, stream: Stream[GetGeometriesRequest, GetGeometriesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        camera = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await camera.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/component_base.py

@@ -1,12 +1,16 @@
 import abc
-from typing import TYPE_CHECKING, ClassVar, List, Mapping, Optional, SupportsBytes, SupportsFloat, Union, cast
+from logging import Logger
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Mapping, Optional, Sequence, SupportsBytes, SupportsFloat, Union, cast
 
 from typing_extensions import Self
 
+from viam.errors import MethodNotImplementedError
+from viam.logging import getLogger
+from viam.proto.common import Geometry
 from viam.resource.base import ResourceBase
 
 if TYPE_CHECKING:
-    from viam.resource.types import Subtype
+    from viam.resource.types import API
     from viam.robot.client import RobotClient
 
 
@@ -19,10 +23,11 @@ class ComponentBase(abc.ABC, ResourceBase):
     All components must inherit from this class.
     """
 
-    SUBTYPE: ClassVar["Subtype"]
+    API: ClassVar["API"]
 
-    def __init__(self, name: str):
+    def __init__(self, name: str, *, logger: Optional[Logger] = None):
         self.name = name
+        self.logger = logger if logger is not None else getLogger(f"{self.API}.{name}")
 
     @classmethod
     def from_robot(cls, robot: "RobotClient", name: str) -> Self:
@@ -36,7 +41,25 @@ class ComponentBase(abc.ABC, ResourceBase):
             Self: The component, if it exists on the robot
         """
         component = robot.get_component(cls.get_resource_name(name))
-        return cast(cls, component)
+        return cast(cls, component)  # type: ignore
 
     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) -> 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.
+
+        ::
+
+            geometries = await component.get_geometries()
+
+            if geometries:
+                # Get the center of the first geometry
+                print(f"Pose of the first geometry's centerpoint: {geometries[0].center}")
+
+        Returns:
+            List[Geometry]: The geometries associated with the Component.
+        """
+        raise MethodNotImplementedError("get_geometries")

viam/components/encoder/__init__.py

@@ -9,7 +9,7 @@ __all__ = [
 ]
 
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         Encoder,
         EncoderRPCService,

viam/components/encoder/client.py

@@ -1,8 +1,8 @@
-from typing import Any, Dict, Mapping, Optional, Tuple
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
 from viam.proto.component.encoder import (
     EncoderServiceStub,
     GetPositionRequest,
@@ -13,7 +13,7 @@ from viam.proto.component.encoder import (
     ResetPositionRequest,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
 from .encoder import Encoder
 
@@ -33,11 +33,11 @@ class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ):
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = ResetPositionRequest(name=self.name, extra=dict_to_struct(extra))
-        await self.client.ResetPosition(request, timeout=timeout)
+        await self.client.ResetPosition(request, timeout=timeout, metadata=md)
 
     async def get_position(
         self,
@@ -45,11 +45,11 @@ class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> Tuple[float, PositionType.ValueType]:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPositionRequest(name=self.name, position_type=position_type, extra=dict_to_struct(extra))
-        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout)
+        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout, metadata=md)
         return response.value, response.position_type
 
     async def get_properties(
@@ -57,16 +57,27 @@ class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> Encoder.Properties:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPropertiesRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetPropertiesResponse = await self.client.GetProperties(request, timeout=timeout)
+        response: GetPropertiesResponse = await self.client.GetProperties(request, timeout=timeout, metadata=md)
         return Encoder.Properties(
             ticks_count_supported=response.ticks_count_supported, angle_degrees_supported=response.angle_degrees_supported
         )
 
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None) -> Mapping[str, ValueTypes]:
+    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)
+        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]:
+        md = kwargs.get("metadata", self.Metadata())
+        return await get_geometries(self.client, self.name, extra, timeout, md)