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

viam/components/movement_sensor/movement_sensor.py

@@ -1,27 +1,41 @@
 import abc
-import asyncio
+import sys
 from dataclasses import dataclass
-from typing import Any, Dict, Final, List, Mapping, Optional, Tuple
+from typing import Any, Dict, Final, Mapping, Optional, Tuple
 
-from grpclib import GRPCError
 from typing_extensions import Self
 
-from viam.errors import MethodNotImplementedError, NotSupportedError
-from viam.proto.component.movementsensor import GetPropertiesResponse
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+from viam.components.component_base import ComponentBase
+from viam.proto.component.movementsensor import GetAccuracyResponse, GetPropertiesResponse
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+from viam.utils import SensorReading
 
-from ..sensor import Sensor
 from . import GeoPoint, Orientation, Vector3
 
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
 
-class MovementSensor(Sensor):
+
+class MovementSensor(ComponentBase):
     """MovementSensor reports information about the robot's direction, position and speed.
 
     This acts as an abstract base class for any sensors that can provide data regarding the robot's direction, position, and speed.
     This cannot be used on its own. If the ``__init__()`` function is overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.movement_sensor import MovementSensor
+
+    For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "movement_sensor")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "movement_sensor"
+    )
+
+    Accuracy: "TypeAlias" = GetAccuracyResponse
 
     @dataclass
     class Properties:
@@ -35,12 +49,12 @@ class MovementSensor(Sensor):
         @property
         def proto(self) -> GetPropertiesResponse:
             return GetPropertiesResponse(
-                linear_acceleration_supported=self.linear_velocity_supported,
+                linear_acceleration_supported=self.linear_acceleration_supported,
                 angular_velocity_supported=self.angular_velocity_supported,
                 orientation_supported=self.orientation_supported,
                 position_supported=self.position_supported,
                 compass_heading_supported=self.compass_heading_supported,
-                linear_velocity_supported=self.linear_acceleration_supported,
+                linear_velocity_supported=self.linear_velocity_supported,
             )
 
         @classmethod
@@ -51,7 +65,7 @@ class MovementSensor(Sensor):
                 orientation_supported=proto.orientation_supported,
                 position_supported=proto.position_supported,
                 compass_heading_supported=proto.compass_heading_supported,
-                linear_velocity_supported=proto.linear_acceleration_supported,
+                linear_velocity_supported=proto.linear_velocity_supported,
             )
 
     @abc.abstractmethod
@@ -60,8 +74,19 @@ class MovementSensor(Sensor):
     ) -> Tuple[GeoPoint, float]:
         """Get the current GeoPoint (latitude, longitude) and altitude (m)
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot,
+                name="my_movement_sensor")
+
+            # Get the current position of the movement sensor.
+            position = await my_movement_sensor.get_position()
+
         Returns:
             Tuple[GeoPoint, float]: The current lat/long, along with the altitude in m
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getposition>`_.
         """
         ...
 
@@ -69,8 +94,18 @@ class MovementSensor(Sensor):
     async def get_linear_velocity(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Vector3:
         """Get the current linear velocity as a ``Vector3`` with x, y, and z axes represented in m/sec
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the current linear velocity of the movement sensor.
+            lin_vel = await my_movement_sensor.get_linear_velocity()
+
         Returns:
             Vector3: The linear velocity in m/sec
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getlinearvelocity>`_.
         """
         ...
 
@@ -78,8 +113,21 @@ class MovementSensor(Sensor):
     async def get_angular_velocity(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Vector3:
         """Get the current angular velocity as a ``Vector3`` with x, y, and z axes represented in degrees/sec
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the current angular velocity of the movement sensor.
+            ang_vel = await my_movement_sensor.get_angular_velocity()
+
+            # Get the y component of angular velocity.
+            y_ang_vel = ang_vel.y
+
         Returns:
             Vector3: The angular velocity in degrees/sec
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getangularvelocity>`_.
         """
         ...
 
@@ -89,8 +137,21 @@ class MovementSensor(Sensor):
     ) -> Vector3:
         """Get the current linear acceleration as a ``Vector3`` with x, y, and z axes represented in m/sec^2
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the current linear acceleration of the movement sensor.
+            lin_accel = await my_movement_sensor.get_linear_acceleration()
+
+            # Get the x component of linear acceleration.
+            x_lin_accel = lin_accel.x
+
         Returns:
             Vector3: The linear acceleration in m/sec^2
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getlinearacceleration>`_.
         """
         ...
 
@@ -98,8 +159,18 @@ class MovementSensor(Sensor):
     async def get_compass_heading(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> float:
         """Get the current compass heading in degrees
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the current compass heading of the movement sensor.
+            heading = await my_movement_sensor.get_compass_heading()
+
         Returns:
             float: The compass heading in degrees
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getcompassheading>`_.
         """
         ...
 
@@ -107,8 +178,18 @@ class MovementSensor(Sensor):
     async def get_orientation(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Orientation:
         """Get the current orientation
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the current orientation vector of the movement sensor.
+            orientation = await my_movement_sensor.get_orientation()
+
         Returns:
             Orientation: The orientation
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getorientation>`_.
         """
         ...
 
@@ -116,69 +197,57 @@ class MovementSensor(Sensor):
     async def get_properties(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Properties:
         """Get the supported properties of this sensor
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the supported properties of the movement sensor.
+            properties = await my_movement_sensor.get_properties()
+
         Returns:
             MovementSensor.Properties: The properties
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getproperties>`_.
         """
         ...
 
     @abc.abstractmethod
-    async def get_accuracy(
-        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
-    ) -> Mapping[str, float]:
+    async def get_accuracy(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Accuracy:
         """Get the accuracy of the various sensors
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the accuracy of the movement sensor.
+            accuracy = await my_movement_sensor.get_accuracy()
+
         Returns:
-            Dict[str, float]: The accuracy
+            MovementSensor.Accuracy: The accuracies of the movement sensor
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getaccuracy>`_.
         """
         ...
 
-    async def get_readings(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Mapping[str, Any]:
+    async def get_readings(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Mapping[str, SensorReading]:
         """Obtain the measurements/data specific to this sensor.
         If a sensor is not configured to have a measurement or fails to read a piece of data, it will not appear in the readings dictionary.
 
+        ::
+
+            my_movement_sensor = MovementSensor.from_robot(
+                robot=robot, name="my_movement_sensor")
+
+            # Get the latest readings from the movement sensor.
+            readings = await my_movement_sensor.get_readings()
+
         Returns:
-            Mapping[str, Any]: The readings for the MovementSensor:
-            {
-                position: GeoPoint,
-                altitude: float,
-                linear_velocity: Vector3,
-                angular_velocity: Vector3,
-                linear_acceleration: Vector3,
-                compass: float,
-                orientation: Orientation,
-            }
+            Mapping[str, Any]: The readings for the MovementSensor. Can be of any type.
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getreadings>`_.
         """
-        (pos, lv, av, la, comp, orient) = await asyncio.gather(
-            self.get_position(extra=extra, timeout=timeout),
-            self.get_linear_velocity(extra=extra, timeout=timeout),
-            self.get_angular_velocity(extra=extra, timeout=timeout),
-            self.get_linear_acceleration(extra=extra, timeout=timeout),
-            self.get_compass_heading(extra=extra, timeout=timeout),
-            self.get_orientation(extra=extra, timeout=timeout),
-            return_exceptions=True,
-        )
-
-        readings = {}
-
-        # Add returned value to the readings dictionary if value is of expected type; omit if unimplemented.
-        def add_reading(name: str, reading, returntype: List) -> None:
-            possible_error_types = (NotImplementedError, MethodNotImplementedError, NotSupportedError)
-            if type(reading) in returntype:
-                if name == "position":
-                    readings["position"] = reading[0]
-                    readings["altitude"] = reading[1]
-                else:
-                    readings[name] = reading
-                return
-            elif isinstance(reading, possible_error_types) or (isinstance(reading, GRPCError) and "Unimplemented" in str(reading.message)):
-                return
-            raise reading
-
-        add_reading("position", pos, [tuple])
-        add_reading("linear_velocity", lv, [Vector3])
-        add_reading("angular_velocity", av, [Vector3])
-        add_reading("linear_acceleration", la, [Vector3])
-        add_reading("compass", comp, [float, int])
-        add_reading("orientation", orient, [Orientation])
-
-        return readings
+        ...

viam/components/movement_sensor/service.py

@@ -1,8 +1,14 @@
 from grpclib.server import Stream
 
 from viam.components.movement_sensor.movement_sensor import MovementSensor
-from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetReadingsRequest,
+    GetReadingsResponse,
+)
 from viam.proto.component.movementsensor import (
     GetAccuracyRequest,
     GetAccuracyResponse,
@@ -23,7 +29,7 @@ from viam.proto.component.movementsensor import (
     MovementSensorServiceBase,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
-from viam.utils import dict_to_struct, struct_to_dict
+from viam.utils import dict_to_struct, sensor_readings_native_to_value, struct_to_dict
 
 
 class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase[MovementSensor]):
@@ -37,10 +43,7 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         velocity = await sensor.get_linear_velocity(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetLinearVelocityResponse(linear_velocity=velocity)
@@ -50,10 +53,7 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         velocity = await sensor.get_angular_velocity(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetAngularVelocityResponse(angular_velocity=velocity)
@@ -63,10 +63,7 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         acceleration = await sensor.get_linear_acceleration(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetLinearAccelerationResponse(linear_acceleration=acceleration)
@@ -76,10 +73,7 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         heading = await sensor.get_compass_heading(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetCompassHeadingResponse(value=heading)
@@ -89,10 +83,7 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         orientation = await sensor.get_orientation(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetOrientationResponse(orientation=orientation)
@@ -102,10 +93,7 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         point, alt = await sensor.get_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetPositionResponse(coordinate=point, altitude_m=alt)
@@ -115,10 +103,7 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         response = await sensor.get_properties(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(response.proto)
@@ -127,23 +112,35 @@ class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            sensor = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         accuracy = await sensor.get_accuracy(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
-        response = GetAccuracyResponse(accuracy=accuracy)
-        await stream.send_message(response)
+        await stream.send_message(accuracy)
 
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            sensor = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        sensor = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await sensor.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
+        sensor = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await sensor.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)
+
+    async def GetReadings(self, stream: Stream[GetReadingsRequest, GetReadingsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        sensor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        readings = await sensor.get_readings(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetReadingsResponse(readings=sensor_readings_native_to_value(readings))
+        await stream.send_message(response)

viam/components/pose_tracker/__init__.py

@@ -8,7 +8,7 @@ __all__ = [
     "PoseTracker",
 ]
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         PoseTracker,
         PoseTrackerRPCService,

viam/components/pose_tracker/client.py

@@ -2,10 +2,10 @@ from typing import Any, Dict, List, Mapping, Optional
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse, PoseInFrame
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, PoseInFrame
 from viam.proto.component.posetracker import GetPosesRequest, GetPosesResponse, PoseTrackerServiceStub
 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 .pose_tracker import PoseTracker
 
@@ -26,14 +26,25 @@ class PoseTrackerClient(PoseTracker, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Mapping[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> Dict[str, PoseInFrame]:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPosesRequest(name=self.name, body_names=body_names, extra=dict_to_struct(extra))
-        response: GetPosesResponse = await self.client.GetPoses(request, timeout=timeout)
+        response: GetPosesResponse = await self.client.GetPoses(request, timeout=timeout, metadata=md)
         return {key: response.body_poses[key] for key in response.body_poses.keys()}
 
-    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)

viam/components/pose_tracker/pose_tracker.py

@@ -2,7 +2,7 @@ import abc
 from typing import Any, Dict, Final, List, Mapping, Optional
 
 from viam.proto.common import PoseInFrame
-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
 
@@ -16,7 +16,9 @@ class PoseTracker(ComponentBase):
     overridden, it must call the ``super().__init__()`` function.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "pose_tracker")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "pose_tracker"
+    )
 
     @abc.abstractmethod
     async def get_poses(

viam/components/pose_tracker/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.posetracker import GetPosesRequest, GetPosesResponse, PoseTrackerServiceBase
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
@@ -20,10 +19,7 @@ class PoseTrackerRPCService(PoseTrackerServiceBase, ResourceRPCServiceBase[PoseT
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            pose_tracker = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        pose_tracker = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         poses = await pose_tracker.get_poses(
             list(request.body_names), extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
@@ -33,11 +29,17 @@ class PoseTrackerRPCService(PoseTrackerServiceBase, ResourceRPCServiceBase[PoseT
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            pose_tracker = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        pose_tracker = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await pose_tracker.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
+        pose_tracker = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await pose_tracker.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/power_sensor/__init__.py

@@ -0,0 +1,17 @@
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import PowerSensorClient
+from .power_sensor import PowerSensor
+from .service import PowerSensorRPCService
+
+__all__ = [
+    "PowerSensor",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        PowerSensor,
+        PowerSensorRPCService,
+        lambda name, channel: PowerSensorClient(name, channel),
+    )
+)

viam/components/power_sensor/client.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict, Mapping, Optional, Tuple
+
+from grpclib.client import Channel
+
+from viam.components.power_sensor.power_sensor import PowerSensor
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetReadingsRequest, GetReadingsResponse
+from viam.proto.component.powersensor import (
+    GetCurrentRequest,
+    GetCurrentResponse,
+    GetPowerRequest,
+    GetPowerResponse,
+    GetVoltageRequest,
+    GetVoltageResponse,
+    PowerSensorServiceStub,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import SensorReading, ValueTypes, dict_to_struct, sensor_readings_value_to_native, struct_to_dict
+
+
+class PowerSensorClient(PowerSensor, ReconfigurableResourceRPCClientBase):
+    """gRPC client for the PowerSensor component."""
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = PowerSensorServiceStub(channel)
+        super().__init__(name)
+
+    async def get_voltage(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[float, bool]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetVoltageRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetVoltageResponse = await self.client.GetVoltage(request, timeout=timeout, metadata=md)
+        return response.volts, response.is_ac
+
+    async def get_current(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[float, bool]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetCurrentRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetCurrentResponse = await self.client.GetCurrent(request, timeout=timeout, metadata=md)
+        return response.amperes, response.is_ac
+
+    async def get_power(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> float:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPowerRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetPowerResponse = await self.client.GetPower(request, timeout=timeout, metadata=md)
+        return response.watts
+
+    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, metadata=md)
+        return struct_to_dict(response.result)