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

viam/components/arm/arm.py

@@ -1,10 +1,10 @@
 import abc
-from typing import Any, Dict, Final, Optional
+from typing import Any, Dict, Final, Optional, Tuple
 
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
 
 from ..component_base import ComponentBase
-from . import JointPositions, Pose
+from . import JointPositions, KinematicsFileFormat, Pose
 
 
 class Arm(ComponentBase):
@@ -14,9 +14,19 @@ class Arm(ComponentBase):
     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/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "arm")
+    API: Final = API(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "arm")  # pyright: ignore [reportIncompatibleVariableOverride]
 
     @abc.abstractmethod
     async def get_end_position(
@@ -27,10 +37,22 @@ class Arm(ComponentBase):
         **kwargs,
     ) -> Pose:
         """
-        Get the current position of the end of the arm expressed as a 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: The location and orientation of the arm described as a Pose.
+            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>`_.
         """
         ...
 
@@ -46,8 +68,23 @@ class Arm(ComponentBase):
         """
         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.
+            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>`_.
         """
         ...
 
@@ -63,8 +100,24 @@ class Arm(ComponentBase):
         """
         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>`_.
         """
         ...
 
@@ -79,8 +132,19 @@ class Arm(ComponentBase):
         """
         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: 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>`_.
         """
         ...
 
@@ -94,6 +158,15 @@ class Arm(ComponentBase):
     ):
         """
         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>`_.
         """
         ...
 
@@ -102,7 +175,49 @@ class Arm(ComponentBase):
         """
         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, **kwargs
+    ) -> 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

@@ -1,8 +1,8 @@
-from typing import Any, Dict, Mapping, Optional
+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, GetKinematicsRequest, GetKinematicsResponse
 from viam.proto.component.arm import (
     ArmServiceStub,
     GetEndPositionRequest,
@@ -17,9 +17,9 @@ from viam.proto.component.arm import (
     StopRequest,
 )
 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 Arm, Pose
+from . import Arm, KinematicsFileFormat, Pose
 
 
 class ArmClient(Arm, ReconfigurableResourceRPCClientBase):
@@ -39,11 +39,11 @@ class ArmClient(Arm, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> Pose:
-        if extra is None:
-            extra = {}
+        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)
+        response: GetEndPositionResponse = await self.client.GetEndPosition(request, timeout=timeout, metadata=md)
         return response.pose
 
     async def move_to_position(
@@ -52,22 +52,22 @@ class ArmClient(Arm, 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 = MoveToPositionRequest(name=self.name, to=pose, extra=dict_to_struct(extra))
-        await self.client.MoveToPosition(request, timeout=timeout)
+        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:
-        if extra is None:
-            extra = {}
+        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)
+        response: GetJointPositionsResponse = await self.client.GetJointPositions(request, timeout=timeout, metadata=md)
         return response.positions
 
     async def move_to_joint_positions(
@@ -76,28 +76,27 @@ class ArmClient(Arm, 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 = MoveToJointPositionsRequest(name=self.name, positions=positions, extra=dict_to_struct(extra))
-        await self.client.MoveToJointPositions(request, timeout=timeout)
+        await self.client.MoveToJointPositions(request, timeout=timeout, metadata=md)
 
     async def stop(
         self,
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ):
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = StopRequest(name=self.name, extra=dict_to_struct(extra))
-        await self.client.Stop(request, timeout=timeout)
+        await self.client.Stop(request, timeout=timeout, metadata=md)
 
-    async def is_moving(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> bool:
-        if extra is None:
-            extra = {}
+    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)
+        response: IsMovingResponse = await self.client.IsMoving(request, timeout=timeout, metadata=md)
         return response.is_moving
 
     async def do_command(
@@ -105,7 +104,21 @@ class ArmClient(Arm, ReconfigurableResourceRPCClientBase):
         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)
+        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

@@ -1,9 +1,14 @@
 from grpclib.server import Stream
 
-from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetKinematicsRequest,
+    GetKinematicsResponse,
+)
 from viam.proto.component.arm import (
-    ArmServiceBase,
     GetEndPositionRequest,
     GetEndPositionResponse,
     GetJointPositionsRequest,
@@ -16,6 +21,7 @@ from viam.proto.component.arm import (
     MoveToPositionResponse,
     StopRequest,
     StopResponse,
+    UnimplementedArmServiceBase,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
@@ -23,7 +29,7 @@ from viam.utils import dict_to_struct, struct_to_dict
 from .arm import Arm
 
 
-class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
+class ArmRPCService(UnimplementedArmServiceBase, ResourceRPCServiceBase[Arm]):
     """
     gRPC Service for an Arm
     """
@@ -34,10 +40,7 @@ class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            arm = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        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)
@@ -47,10 +50,7 @@ class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            arm = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        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()
@@ -60,10 +60,7 @@ class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            arm = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        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)
@@ -73,10 +70,7 @@ class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            arm = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        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()
@@ -86,10 +80,7 @@ class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            arm = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        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()
@@ -99,10 +90,7 @@ class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            arm = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        arm = self.get_resource(name)
         is_moving = await arm.is_moving()
         response = IsMovingResponse(is_moving=is_moving)
         await stream.send_message(response)
@@ -110,11 +98,26 @@ class ArmRPCService(ArmServiceBase, ResourceRPCServiceBase[Arm]):
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            arm = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        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, metadata=stream.metadata)
+        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_in/__init__.py

@@ -0,0 +1,24 @@
+from viam.media.audio import AudioCodec
+from viam.proto.common import AudioInfo
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .audio_in import AudioIn
+from .client import AudioInClient
+from .service import AudioInRPCService
+
+AudioResponse = AudioIn.AudioResponse
+
+__all__ = [
+    "AudioIn",
+    "AudioResponse",
+    "AudioInfo",
+    "AudioCodec",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        AudioIn,
+        AudioInRPCService,
+        lambda name, channel: AudioInClient(name, channel),
+    )
+)

viam/components/audio_in/audio_in.py

@@ -0,0 +1,74 @@
+import abc
+import sys
+from typing import Final, Optional
+
+from viam.proto.common import GetPropertiesResponse
+from viam.proto.component.audioin import GetAudioResponse
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+from viam.streams import Stream
+
+from ..component_base import ComponentBase
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+class AudioIn(ComponentBase):
+    """AudioIn 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_in"
+    )
+
+    Properties: "TypeAlias" = GetPropertiesResponse
+    AudioResponse: "TypeAlias" = GetAudioResponse
+    AudioStream = Stream[AudioResponse]
+
+    @abc.abstractmethod
+    async def get_audio(
+        self, codec: str, duration_seconds: float, previous_timestamp_ns: int, *, timeout: Optional[float] = None, **kwargs
+    ) -> AudioStream:
+        """
+        Get a stream of audio from the device
+
+        ::
+
+            my_audio_in = AudioIn.from_robot(robot=machine, name="my_audio_in")
+
+            stream = await my_audio_in.get_audio(
+                codec=AudioCodec.PCM16,
+                duration_seconds=10.0,
+                previous_timestamp_ns=0
+            )
+
+        Args:
+            codec (str): The desired codec of the returned audio data
+            duration_seconds (float): duration of the stream. 0 = indefinite stream
+            previous_timestamp_ns (int): starting timestamp in nanoseconds for recording continuity.
+            Set to 0 to begin recording from the current time.
+        Returns:
+            AudioStream: stream of audio chunks.
+        ...
+        """
+
+    @abc.abstractmethod
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> Properties:
+        """
+        Get the audio device's properties
+
+        ::
+
+            my_audio_in = AudioIn.from_robot(robot=machine, name="my_audio_in")
+            properties = await my_audio_in.get_properties()
+
+        Returns:
+            Properties: The properties of the audio in device.
+        ...
+        """

viam/components/audio_in/client.py

@@ -0,0 +1,76 @@
+import uuid
+from typing import Any, Dict, List, Mapping, Optional
+
+from grpclib.client import Channel
+from grpclib.client import Stream as ClientStream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetPropertiesRequest
+from viam.proto.component.audioin import AudioInServiceStub, GetAudioRequest, GetAudioResponse
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.streams import StreamWithIterator
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from .audio_in import AudioIn
+
+
+class AudioInClient(AudioIn, ReconfigurableResourceRPCClientBase):
+    def __init__(self, name: str, channel: Channel) -> None:
+        self.channel = channel
+        self.client = AudioInServiceStub(channel)
+        super().__init__(name)
+
+    async def get_audio(
+        self,
+        codec: str,
+        duration_seconds: float,
+        previous_timestamp_ns: int,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        request = GetAudioRequest(
+            name=self.name,
+            codec=codec,
+            duration_seconds=duration_seconds,
+            previous_timestamp_nanoseconds=previous_timestamp_ns,
+            request_id=str(uuid.uuid4()),
+            extra=dict_to_struct(extra),
+        )
+
+        async def read():
+            md = kwargs.get("metadata", self.Metadata()).proto
+            audio_stream: ClientStream[GetAudioRequest, GetAudioResponse]
+            async with self.client.GetAudio.open(metadata=md) as audio_stream:
+                try:
+                    await audio_stream.send_message(request, end=True)
+                    async for response in audio_stream:
+                        yield response
+                except Exception as e:
+                    raise (e)
+
+        return StreamWithIterator(read())
+
+    async def get_properties(
+        self,
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> AudioIn.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,
+        **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)