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

viam/components/motor/motor.py

@@ -2,7 +2,7 @@ import abc
 from dataclasses import dataclass
 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
 
@@ -13,13 +13,21 @@ class Motor(ComponentBase):
     This acts as an abstract base class for any drivers representing specific
     motor implementations. This cannot be used on its own. If the ``__init__()`` function is
     overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.motor import Motor
+
+    For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/>`_.
     """
 
     @dataclass
     class Properties:
         position_reporting: bool
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "motor")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "motor"
+    )
 
     @abc.abstractmethod
     async def set_power(
@@ -34,9 +42,18 @@ class Motor(ComponentBase):
         Sets the "percentage" of power the motor should employ between -1 and 1.
         When ``power`` is negative, the rotation will be in the backward direction.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Set the power to 40% forwards.
+            await my_motor.set_power(power=0.4)
+
         Args:
             power (float): Power between -1 and 1
                 (negative implies backwards).
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#setpower>`_.
         """
         ...
 
@@ -55,11 +72,20 @@ class Motor(ComponentBase):
         When ``rpm`` or ``revolutions`` is a negative value, the rotation will be in the backward direction.
         Note: if both ``rpm`` and ``revolutions`` are negative, the motor will spin in the forward direction.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Turn the motor 7.2 revolutions at 60 RPM.
+            await my_motor.go_for(rpm=60, revolutions=7.2)
+
         Args:
             rpm (float): Speed at which the motor should move in rotations per minute
                 (negative implies backwards).
             revolutions (float): Number of revolutions the motor should run for
                 (negative implies backwards).
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#gofor>`_.
         """
         ...
 
@@ -79,9 +105,45 @@ class Motor(ComponentBase):
         Regardless of the directionality of the ``rpm`` this function will move
         the motor towards the specified position.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Turn the motor to 8.3 revolutions from home at 75 RPM.
+            await my_motor.go_to(rpm=75, revolutions=8.3)
+
         Args:
             rpm (float): Speed at which the motor should rotate (absolute value).
             position_revolutions (float): Target position relative to home/zero, in revolutions.
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#goto>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def set_rpm(
+        self,
+        rpm: float,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Spin the motor indefinitely at the specified speed, in revolutions per minute.
+        Positive ``rpm`` will result in forward movement and negative ``rpm`` will result in backwards movement
+
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Spin the motor at 75 RPM.
+            await my_motor.set_rpm(rpm=75)
+
+        Args:
+            rpm (float): Speed at which the motor should rotate.
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#setrpm>`_.
         """
         ...
 
@@ -97,8 +159,17 @@ class Motor(ComponentBase):
         """
         Set the current position (modified by ``offset``) to be the new zero (home) position.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Set the current position as the new home position with no offset.
+            await my_motor.reset_zero_position(offset=0.0)
+
         Args:
             offset (float): The offset from the current position to new home/zero position.
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#resetzeroposition>`_.
         """
         ...
 
@@ -115,8 +186,17 @@ class Motor(ComponentBase):
         The value returned is the number of revolutions relative to its zero position.
         This method will raise an exception if position reporting is not supported by the motor.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Get the current position of the motor.
+            position = await my_motor.get_position()
+
         Returns:
             float: Number of revolutions the motor is away from zero/home.
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#getposition>`_.
         """
         ...
 
@@ -132,8 +212,21 @@ class Motor(ComponentBase):
         Report a dictionary mapping optional properties to
         whether it is supported by this motor.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Report a dictionary mapping optional properties to whether it is supported by
+            # this motor.
+            properties = await my_motor.get_properties()
+
+            # Print out the properties.
+            print(f'Properties: {properties}')
+
         Returns:
             Properties: Map of feature names to supported status.
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#getproperties>`_.
         """
         ...
 
@@ -147,6 +240,15 @@ class Motor(ComponentBase):
     ):
         """
         Stop the motor immediately, without any gradual step down.
+
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Stop the motor.
+            await my_motor.stop()
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#stop>`_.
         """
         ...
 
@@ -161,9 +263,20 @@ class Motor(ComponentBase):
         """
         Returns whether or not the motor is currently running.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Check whether the motor is currently running.
+            powered = await my_motor.is_powered()
+
+            print('Powered: ', powered)
+
         Returns:
-            bool: Indicates whether the motor is currently powered.
-            float: The current power percentage of the motor
+            Tuple[bool, float]: A tuple containing two values; the first [0] value indicates whether the motor is currently powered, and
+            the second [1] value indicates the current power percentage of the motor.
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#ispowered>`_.
         """
         ...
 
@@ -172,7 +285,17 @@ class Motor(ComponentBase):
         """
         Get if the motor is currently moving.
 
+        ::
+
+            my_motor = Motor.from_robot(robot=machine, name="my_motor")
+
+            # Check whether the motor is currently moving.
+            moving = await my_motor.is_moving()
+            print('Moving: ', moving)
+
         Returns:
             bool: Whether the motor is moving.
+
+        For more information, see `Motor component <https://docs.viam.com/dev/reference/apis/components/motor/#ismoving>`_.
         """
         ...

viam/components/motor/service.py

@@ -1,7 +1,6 @@
 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
 from viam.proto.component.motor import (
     GetPositionRequest,
     GetPositionResponse,
@@ -15,13 +14,15 @@ from viam.proto.component.motor import (
     IsMovingResponse,
     IsPoweredRequest,
     IsPoweredResponse,
-    MotorServiceBase,
     ResetZeroPositionRequest,
     ResetZeroPositionResponse,
     SetPowerRequest,
     SetPowerResponse,
+    SetRPMRequest,
+    SetRPMResponse,
     StopRequest,
     StopResponse,
+    UnimplementedMotorServiceBase,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
@@ -29,7 +30,7 @@ from viam.utils import dict_to_struct, struct_to_dict
 from .motor import Motor
 
 
-class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
+class MotorRPCService(UnimplementedMotorServiceBase, ResourceRPCServiceBase[Motor]):
     """
     gRPC Service for a Motor
     """
@@ -40,10 +41,7 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await motor.set_power(request.power_pct, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(SetPowerResponse())
@@ -52,10 +50,7 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await motor.go_for(request.rpm, request.revolutions, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(GoForResponse())
@@ -64,24 +59,27 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await motor.go_to(
             request.rpm, request.position_revolutions, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
         )
         await stream.send_message(GoToResponse())
 
+    async def SetRPM(self, stream: Stream[SetRPMRequest, SetRPMResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await motor.set_rpm(request.rpm, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(SetRPMResponse())
+
     async def ResetZeroPosition(self, stream: Stream[ResetZeroPositionRequest, ResetZeroPositionResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await motor.reset_zero_position(request.offset, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(ResetZeroPositionResponse())
@@ -90,10 +88,7 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         position = await motor.get_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(GetPositionResponse(position=position))
@@ -102,10 +97,7 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         properties = await motor.get_properties(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetPropertiesResponse(**properties.__dict__)
@@ -115,10 +107,7 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await motor.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = StopResponse()
@@ -128,10 +117,7 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         is_powered, power_pct = await motor.is_powered(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(IsPoweredResponse(is_on=is_powered, power_pct=power_pct))
@@ -140,10 +126,7 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            motor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(name)
         is_moving = await motor.is_moving()
         response = IsMovingResponse(is_moving=is_moving)
         await stream.send_message(response)
@@ -151,11 +134,17 @@ class MotorRPCService(MotorServiceBase, ResourceRPCServiceBase[Motor]):
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            motor = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        motor = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await motor.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
+        motor = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await motor.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/movement_sensor/__init__.py

@@ -12,7 +12,7 @@ __all__ = [
     "Vector3",
 ]
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         MovementSensor,
         MovementSensorRPCService,

viam/components/movement_sensor/client.py

@@ -1,12 +1,11 @@
-from typing import Any, Dict, Mapping, Optional, Tuple
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 from grpclib.client import Channel
 
 from viam.components.movement_sensor.movement_sensor import MovementSensor
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetReadingsRequest, GetReadingsResponse
 from viam.proto.component.movementsensor import (
     GetAccuracyRequest,
-    GetAccuracyResponse,
     GetAngularVelocityRequest,
     GetAngularVelocityResponse,
     GetCompassHeadingRequest,
@@ -24,7 +23,7 @@ from viam.proto.component.movementsensor import (
     MovementSensorServiceStub,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+from viam.utils import SensorReading, ValueTypes, dict_to_struct, get_geometries, sensor_readings_value_to_native, struct_to_dict
 
 from . import GeoPoint, Orientation, Vector3
 
@@ -37,68 +36,126 @@ class MovementSensorClient(MovementSensor, ReconfigurableResourceRPCClientBase):
         self.client = MovementSensorServiceStub(channel)
         super().__init__(name)
 
-    async def get_position(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Tuple[GeoPoint, float]:
-        if extra is None:
-            extra = {}
+    async def get_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[GeoPoint, float]:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPositionRequest(name=self.name, 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.coordinate, response.altitude_m
 
-    async def get_linear_velocity(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Vector3:
-        if extra is None:
-            extra = {}
+    async def get_linear_velocity(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Vector3:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetLinearVelocityRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetLinearVelocityResponse = await self.client.GetLinearVelocity(request, timeout=timeout)
+        response: GetLinearVelocityResponse = await self.client.GetLinearVelocity(request, timeout=timeout, metadata=md)
         return response.linear_velocity
 
-    async def get_angular_velocity(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Vector3:
-        if extra is None:
-            extra = {}
+    async def get_angular_velocity(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Vector3:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetAngularVelocityRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetAngularVelocityResponse = await self.client.GetAngularVelocity(request, timeout=timeout)
+        response: GetAngularVelocityResponse = await self.client.GetAngularVelocity(request, timeout=timeout, metadata=md)
         return response.angular_velocity
 
-    async def get_linear_acceleration(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Vector3:
-        if extra is None:
-            extra = {}
+    async def get_linear_acceleration(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Vector3:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetLinearAccelerationRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetLinearAccelerationResponse = await self.client.GetLinearAcceleration(request, timeout=timeout)
+        response: GetLinearAccelerationResponse = await self.client.GetLinearAcceleration(request, timeout=timeout, metadata=md)
         return response.linear_acceleration
 
-    async def get_compass_heading(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> float:
-        if extra is None:
-            extra = {}
+    async def get_compass_heading(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> float:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetCompassHeadingRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetCompassHeadingResponse = await self.client.GetCompassHeading(request, timeout=timeout)
+        response: GetCompassHeadingResponse = await self.client.GetCompassHeading(request, timeout=timeout, metadata=md)
         return response.value
 
-    async def get_orientation(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Orientation:
-        if extra is None:
-            extra = {}
+    async def get_orientation(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Orientation:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetOrientationRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetOrientationResponse = await self.client.GetOrientation(request, timeout=timeout)
+        response: GetOrientationResponse = await self.client.GetOrientation(request, timeout=timeout, metadata=md)
         return response.orientation
 
-    async def get_properties(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> MovementSensor.Properties:
-        if extra is None:
-            extra = {}
+    async def get_properties(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> MovementSensor.Properties:
+        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 MovementSensor.Properties.from_proto(response)
 
-    async def get_accuracy(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Mapping[str, float]:
-        if extra is None:
-            extra = {}
+    async def get_accuracy(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> MovementSensor.Accuracy:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetAccuracyRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetAccuracyResponse = await self.client.GetAccuracy(request, timeout=timeout)
-        return response.accuracy
-
-    async def get_readings(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Mapping[str, Any]:
-        if extra is None:
-            extra = {}
-        return await super().get_readings(extra=extra, timeout=timeout)
-
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None) -> Mapping[str, ValueTypes]:
+        return await self.client.GetAccuracy(request, timeout=timeout, metadata=md)
+
+    async def get_readings(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, SensorReading]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetReadingsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetReadingsResponse = await self.client.GetReadings(request, timeout=timeout, metadata=md)
+
+        return sensor_readings_value_to_native(response.readings)
+
+    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)