viam-sdk 0.45.2__py3-none-win_amd64.whl

viam/components/arm/arm.py

@@ -0,0 +1,223 @@
+import abc
+from typing import Any, Dict, Final, Optional, Tuple
+
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from ..component_base import ComponentBase
+from . import JointPositions, KinematicsFileFormat, Pose
+
+
+class Arm(ComponentBase):
+    """
+    Arm represents a physical robot arm that exists in three-dimensional space.
+
+    This acts as an abstract base class for any drivers representing specific
+    arm implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.arm import Arm
+        # To use move_to_position:
+        from viam.proto.common import Pose
+        # To use move_to_joint_positions:
+        from viam.proto.component.arm import JointPositions
+
+    For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/>`_.
+    """
+
+    API: Final = API(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "arm")  # pyright: ignore [reportIncompatibleVariableOverride]
+
+    @abc.abstractmethod
+    async def get_end_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Pose:
+        """
+        Get the current position of the end of the arm expressed as a ``Pose``.
+
+        ::
+
+            my_arm = Arm.from_robot(robot=machine, name="my_arm")
+
+            # Get the end position of the arm as a Pose.
+            pos = await my_arm.get_end_position()
+
+        Returns:
+            Pose: A representation of the arm's current position as a 6 DOF (six degrees of freedom) pose.
+            The ``Pose`` is composed of values for location and orientation with respect to the origin.
+            Location is expressed as distance, which is represented by x, y, and z coordinate values.
+            Orientation is expressed as an orientation vector, which is represented by o_x, o_y, o_z, and theta values.
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#getendposition>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def move_to_position(
+        self,
+        pose: Pose,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Move the end of the arm to the Pose specified in ``pose``.
+
+        ::
+
+            my_arm = Arm.from_robot(robot=machine, name="my_arm")
+
+            # Create a Pose for the arm.
+            examplePose = Pose(x=5, y=5, z=5, o_x=5, o_y=5, o_z=5, theta=20)
+
+            # Move your arm to the Pose.
+            await my_arm.move_to_position(pose=examplePose)
+
+        Args:
+            pose (Pose): The destination ``Pose`` for the arm. The ``Pose`` is composed of values for location and orientation
+                with respect to the origin.
+                Location is expressed as distance, which is represented by x, y, and z coordinate values.
+                Orientation is expressed as an orientation vector, which is represented by o_x, o_y, o_z, and theta values.
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#movetoposition>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def move_to_joint_positions(
+        self,
+        positions: JointPositions,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Move each joint on the arm to the corresponding angle specified in ``positions``.
+
+        ::
+
+            my_arm = Arm.from_robot(robot=machine, name="my_arm")
+
+            # Declare a list of values with your desired rotational value for each joint on
+            # the arm. This example is for a 5dof arm.
+            degrees = [0.0, 45.0, 0.0, 0.0, 0.0]
+
+            # Declare a new JointPositions with these values.
+            jointPos = JointPositions(values=degrees)
+
+            # Move each joint of the arm to the position these values specify.
+            await my_arm.move_to_joint_positions(positions=jointPos)
+
+        Args:
+            positions (JointPositions): The destination ``JointPositions`` for the arm.
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#movetojointpositions>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_joint_positions(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> JointPositions:
+        """
+        Get the JointPositions representing the current position of the arm.
+
+        ::
+
+            my_arm = Arm.from_robot(robot=machine, name="my_arm")
+
+            # Get the current position of each joint on the arm as JointPositions.
+            pos = await my_arm.get_joint_positions()
+
+        Returns:
+            JointPositions: The current ``JointPositions`` for the arm.
+            ``JointPositions`` can have one attribute, ``values``, a list of joint positions with rotational values (degrees)
+            and translational values (mm).
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#getjointpositions>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def stop(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Stop all motion of the arm. It is assumed that the arm stops immediately.
+
+        ::
+
+            my_arm = Arm.from_robot(robot=machine, name="my_arm")
+
+            # Stop all motion of the arm. It is assumed that the arm stops immediately.
+            await my_arm.stop()
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#stop>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def is_moving(self) -> bool:
+        """
+        Get if the arm is currently moving.
+
+        ::
+
+            my_arm = Arm.from_robot(robot=machine, name="my_arm")
+
+            # Stop all motion of the arm. It is assumed that the arm stops immediately.
+            await my_arm.stop()
+
+            # Print if the arm is currently moving.
+            print(await my_arm.is_moving())
+
+        Returns:
+            bool: Whether the arm is moving.
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#ismoving>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_kinematics(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        """
+        Get the kinematics information associated with the arm.
+
+        ::
+
+            my_arm = Arm.from_robot(robot=machine, name="my_arm")
+
+            # Get the kinematics information associated with the arm.
+            kinematics = await my_arm.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/arm/client.py

@@ -0,0 +1,124 @@
+from typing import Any, Dict, List, Mapping, Optional, Tuple
+
+from grpclib.client import Channel
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetKinematicsRequest, GetKinematicsResponse
+from viam.proto.component.arm import (
+    ArmServiceStub,
+    GetEndPositionRequest,
+    GetEndPositionResponse,
+    GetJointPositionsRequest,
+    GetJointPositionsResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    JointPositions,
+    MoveToJointPositionsRequest,
+    MoveToPositionRequest,
+    StopRequest,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from . import Arm, KinematicsFileFormat, Pose
+
+
+class ArmClient(Arm, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for an Arm component.
+
+    Used to communicate with an existing ``Arm`` implementation over gRPC.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = ArmServiceStub(channel)
+        super().__init__(name)
+
+    async def get_end_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Pose:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetEndPositionRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetEndPositionResponse = await self.client.GetEndPosition(request, timeout=timeout, metadata=md)
+        return response.pose
+
+    async def move_to_position(
+        self,
+        pose: Pose,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = MoveToPositionRequest(name=self.name, to=pose, extra=dict_to_struct(extra))
+        await self.client.MoveToPosition(request, timeout=timeout, metadata=md)
+
+    async def get_joint_positions(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> JointPositions:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetJointPositionsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetJointPositionsResponse = await self.client.GetJointPositions(request, timeout=timeout, metadata=md)
+        return response.positions
+
+    async def move_to_joint_positions(
+        self,
+        positions: JointPositions,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = MoveToJointPositionsRequest(name=self.name, positions=positions, extra=dict_to_struct(extra))
+        await self.client.MoveToJointPositions(request, timeout=timeout, metadata=md)
+
+    async def stop(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = StopRequest(name=self.name, extra=dict_to_struct(extra))
+        await self.client.Stop(request, timeout=timeout, metadata=md)
+
+    async def is_moving(self, *, timeout: Optional[float] = None, **kwargs) -> bool:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = IsMovingRequest(name=self.name)
+        response: IsMovingResponse = await self.client.IsMoving(request, timeout=timeout, metadata=md)
+        return response.is_moving
+
+    async def do_command(
+        self,
+        command: Mapping[str, Any],
+        *,
+        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)
+
+    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/arm/service.py

@@ -0,0 +1,123 @@
+from grpclib.server import Stream
+
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetKinematicsRequest,
+    GetKinematicsResponse,
+)
+from viam.proto.component.arm import (
+    GetEndPositionRequest,
+    GetEndPositionResponse,
+    GetJointPositionsRequest,
+    GetJointPositionsResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    MoveToJointPositionsRequest,
+    MoveToJointPositionsResponse,
+    MoveToPositionRequest,
+    MoveToPositionResponse,
+    StopRequest,
+    StopResponse,
+    UnimplementedArmServiceBase,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .arm import Arm
+
+
+class ArmRPCService(UnimplementedArmServiceBase, ResourceRPCServiceBase[Arm]):
+    """
+    gRPC Service for an Arm
+    """
+
+    RESOURCE_TYPE = Arm
+
+    async def GetEndPosition(self, stream: Stream[GetEndPositionRequest, GetEndPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        arm = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        position = await arm.get_end_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetEndPositionResponse(pose=position)
+        await stream.send_message(response)
+
+    async def MoveToPosition(self, stream: Stream[MoveToPositionRequest, MoveToPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        arm = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await arm.move_to_position(request.to, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = MoveToPositionResponse()
+        await stream.send_message(response)
+
+    async def GetJointPositions(self, stream: Stream[GetJointPositionsRequest, GetJointPositionsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        arm = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        positions = await arm.get_joint_positions(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetJointPositionsResponse(positions=positions)
+        await stream.send_message(response)
+
+    async def MoveToJointPositions(self, stream: Stream[MoveToJointPositionsRequest, MoveToJointPositionsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        arm = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await arm.move_to_joint_positions(request.positions, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = MoveToJointPositionsResponse()
+        await stream.send_message(response)
+
+    async def Stop(self, stream: Stream[StopRequest, StopResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        arm = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await arm.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = StopResponse()
+        await stream.send_message(response)
+
+    async def IsMoving(self, stream: Stream[IsMovingRequest, IsMovingResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        arm = self.get_resource(name)
+        is_moving = await arm.is_moving()
+        response = IsMovingResponse(is_moving=is_moving)
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        arm = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await arm.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 GetKinematics(self, stream: Stream[GetKinematicsRequest, GetKinematicsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        arm = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        format, kinematics_data = await arm.get_kinematics(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetKinematicsResponse(format=format, kinematics_data=kinematics_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)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await arm.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/audio_input/__init__.py

@@ -0,0 +1,18 @@
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .audio_input import AudioInput
+from .client import AudioInputClient
+from .service import AudioInputRPCService
+
+__all__ = [
+    "AudioInput",
+]
+
+
+Registry.register_api(
+    ResourceRegistration(
+        AudioInput,
+        AudioInputRPCService,
+        lambda name, channel: AudioInputClient(name, channel),
+    )
+)

viam/components/audio_input/audio_input.py

@@ -0,0 +1,81 @@
+import abc
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Final, Optional
+
+from google.protobuf.duration_pb2 import Duration
+from typing_extensions import Self
+
+from viam.media.audio import Audio, AudioStream
+from viam.proto.component.audioinput import PropertiesResponse
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+from viam.streams import StreamSource
+
+from ..component_base import ComponentBase
+
+
+class AudioInput(ComponentBase, StreamSource[Audio]):
+    """AudioInput represents a component that can capture audio.
+
+    This acts as an abstract base class for any drivers representing specific
+    audio input implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "audio_input"
+    )
+
+    @dataclass
+    class Properties:
+        channel_count: int
+        latency: timedelta
+        sample_rate: int
+        sample_size: int
+        is_big_endian: bool
+        is_float: bool
+        is_interleaved: bool
+
+        @property
+        def proto(self) -> PropertiesResponse:
+            latency = Duration()
+            latency.FromTimedelta(self.latency)
+            return PropertiesResponse(
+                channel_count=self.channel_count,
+                latency=latency,
+                sample_rate=self.sample_rate,
+                sample_size=self.sample_size,
+                is_big_endian=self.is_big_endian,
+                is_float=self.is_float,
+                is_interleaved=self.is_interleaved,
+            )
+
+        @classmethod
+        def from_proto(cls, proto: PropertiesResponse) -> Self:
+            return cls(
+                channel_count=proto.channel_count,
+                latency=proto.latency.ToTimedelta(),
+                sample_rate=proto.sample_rate,
+                sample_size=proto.sample_size,
+                is_big_endian=proto.is_big_endian,
+                is_float=proto.is_float,
+                is_interleaved=proto.is_interleaved,
+            )
+
+    @abc.abstractmethod
+    async def stream(self, *, timeout: Optional[float] = None, **kwargs) -> AudioStream:
+        """Stream audio samples from the audio input of the underlying robot
+
+        Returns:
+            Stream[Audio]: The stream of audio chunks
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> Properties:
+        """Get the properties of the audio input of the underlying robot
+
+        Returns:
+            Properties: The audio input properties
+        """
+        ...

viam/components/audio_input/client.py

@@ -0,0 +1,70 @@
+from typing import Any, AsyncIterator, Dict, List, Mapping, Optional, Union
+
+from grpclib.client import Channel
+
+from viam.media.audio import Audio
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
+from viam.proto.component.audioinput import (
+    AudioInputServiceStub,
+    ChunksRequest,
+    ChunksResponse,
+    PropertiesRequest,
+    PropertiesResponse,
+    SampleFormat,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.streams import Stream, StreamWithIterator
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from .audio_input import AudioInput
+
+
+class AudioInputClient(AudioInput, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the AudioInput component.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = AudioInputServiceStub(channel)
+        super().__init__(name)
+
+    async def stream(self, *, timeout: Optional[float] = None, **kwargs) -> Stream[Audio]:
+        async def read() -> AsyncIterator[Audio]:
+            md = kwargs.get("metadata", self.Metadata()).proto
+            async with self.client.Chunks.open(timeout=timeout, metadata=md) as chunks_stream:
+                await chunks_stream.send_message(
+                    ChunksRequest(name=self.name, sample_format=SampleFormat.SAMPLE_FORMAT_FLOAT32_INTERLEAVED), end=True
+                )
+                response: Union[ChunksResponse, None] = await chunks_stream.recv_message()
+                if not response:
+                    await chunks_stream.recv_trailing_metadata()  # causes us to throw appropriate gRPC error.
+                    raise TypeError("Response cannot be empty")  # we should never get here, but for typechecking
+                assert response.HasField("info")
+                info = response.info
+
+                while True:
+                    response = await chunks_stream.recv_message()
+                    if response is None:
+                        break
+                    assert response.HasField("chunk")
+                    audio = Audio(info=info, chunk=response.chunk)
+                    yield audio
+
+        return StreamWithIterator(read())
+
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> AudioInput.Properties:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = PropertiesRequest(name=self.name)
+        response: PropertiesResponse = await self.client.Properties(request, timeout=timeout, metadata=md)
+        return AudioInput.Properties.from_proto(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)
+
+    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)