viam-sdk 0.45.2__py3-none-win_amd64.whl

viam/components/movement_sensor/service.py

@@ -0,0 +1,146 @@
+from grpclib.server import Stream
+
+from viam.components.movement_sensor.movement_sensor import MovementSensor
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetReadingsRequest,
+    GetReadingsResponse,
+)
+from viam.proto.component.movementsensor import (
+    GetAccuracyRequest,
+    GetAccuracyResponse,
+    GetAngularVelocityRequest,
+    GetAngularVelocityResponse,
+    GetCompassHeadingRequest,
+    GetCompassHeadingResponse,
+    GetLinearAccelerationRequest,
+    GetLinearAccelerationResponse,
+    GetLinearVelocityRequest,
+    GetLinearVelocityResponse,
+    GetOrientationRequest,
+    GetOrientationResponse,
+    GetPositionRequest,
+    GetPositionResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    MovementSensorServiceBase,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, sensor_readings_native_to_value, struct_to_dict
+
+
+class MovementSensorRPCService(MovementSensorServiceBase, ResourceRPCServiceBase[MovementSensor]):
+    """
+    gRPC Service for a MovementSensor
+    """
+
+    RESOURCE_TYPE = MovementSensor
+
+    async def GetLinearVelocity(self, stream: Stream[GetLinearVelocityRequest, GetLinearVelocityResponse]) -> 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
+        velocity = await sensor.get_linear_velocity(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetLinearVelocityResponse(linear_velocity=velocity)
+        await stream.send_message(response)
+
+    async def GetAngularVelocity(self, stream: Stream[GetAngularVelocityRequest, GetAngularVelocityResponse]) -> 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
+        velocity = await sensor.get_angular_velocity(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetAngularVelocityResponse(angular_velocity=velocity)
+        await stream.send_message(response)
+
+    async def GetLinearAcceleration(self, stream: Stream[GetLinearAccelerationRequest, GetLinearAccelerationResponse]) -> 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
+        acceleration = await sensor.get_linear_acceleration(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetLinearAccelerationResponse(linear_acceleration=acceleration)
+        await stream.send_message(response)
+
+    async def GetCompassHeading(self, stream: Stream[GetCompassHeadingRequest, GetCompassHeadingResponse]) -> 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
+        heading = await sensor.get_compass_heading(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetCompassHeadingResponse(value=heading)
+        await stream.send_message(response)
+
+    async def GetOrientation(self, stream: Stream[GetOrientationRequest, GetOrientationResponse]) -> 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
+        orientation = await sensor.get_orientation(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetOrientationResponse(orientation=orientation)
+        await stream.send_message(response)
+
+    async def GetPosition(self, stream: Stream[GetPositionRequest, GetPositionResponse]) -> 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
+        point, alt = await sensor.get_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetPositionResponse(coordinate=point, altitude_m=alt)
+        await stream.send_message(response)
+
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> 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
+        response = await sensor.get_properties(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(response.proto)
+
+    async def GetAccuracy(self, stream: Stream[GetAccuracyRequest, GetAccuracyResponse]) -> 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
+        accuracy = await sensor.get_accuracy(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(accuracy)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> 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
+        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

@@ -0,0 +1,17 @@
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import PoseTrackerClient
+from .pose_tracker import PoseTracker
+from .service import PoseTrackerRPCService
+
+__all__ = [
+    "PoseTracker",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        PoseTracker,
+        PoseTrackerRPCService,
+        lambda name, channel: PoseTrackerClient(name, channel),
+    )
+)

viam/components/pose_tracker/client.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, List, Mapping, Optional
+
+from grpclib.client import Channel
+
+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, get_geometries, struct_to_dict
+
+from .pose_tracker import PoseTracker
+
+
+class PoseTrackerClient(PoseTracker, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the PoseTracker component.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = PoseTrackerServiceStub(channel)
+        super().__init__(name)
+
+    async def get_poses(
+        self,
+        body_names: List[str],
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Dict[str, PoseInFrame]:
+        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, 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,
+        **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)

viam/components/pose_tracker/pose_tracker.py

@@ -0,0 +1,40 @@
+import abc
+from typing import Any, Dict, Final, List, Mapping, Optional
+
+from viam.proto.common import PoseInFrame
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from ..component_base import ComponentBase
+
+
+class PoseTracker(ComponentBase):
+    """
+    PoseTracker represents a physical pose or motion tracking device.
+
+    This acts as an abstract base class for any drivers representing specific
+    pose tracker 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, "pose_tracker"
+    )
+
+    @abc.abstractmethod
+    async def get_poses(
+        self,
+        body_names: List[str],
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Dict[str, PoseInFrame]:
+        """
+        Returns the current pose of each body tracked by the pose tracker.
+
+        Args:
+            body_names (List[str]): Names of the bodies whose poses are being
+                requested. In the event this parameter is not supplied or is
+                an empty list, all available poses are returned.
+        """
+        ...

viam/components/pose_tracker/service.py

@@ -0,0 +1,45 @@
+from grpclib.server import Stream
+
+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
+
+from .pose_tracker import PoseTracker
+
+
+class PoseTrackerRPCService(PoseTrackerServiceBase, ResourceRPCServiceBase[PoseTracker]):
+    """
+    gRPC service for a pose tracker
+    """
+
+    RESOURCE_TYPE = PoseTracker
+
+    async def GetPoses(self, stream: Stream[GetPosesRequest, GetPosesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        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
+        )
+        await stream.send_message(GetPosesResponse(body_poses=poses))
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> 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
+        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)

viam/components/power_sensor/power_sensor.py

@@ -0,0 +1,104 @@
+import abc
+from typing import Any, Dict, Final, Mapping, Optional, Tuple
+
+from viam.components.component_base import ComponentBase
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+from viam.utils import SensorReading
+
+
+class PowerSensor(ComponentBase):
+    """PowerSensor reports information about voltage, current and power.
+
+    This acts as an abstract base class for any sensors that can provide data regarding voltage, current and/or power.
+    This cannot be used on its own. If the ``__init__()`` function is overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.power_sensor import PowerSensor
+
+    For more information, see `Power Sensor component <https://docs.viam.com/dev/reference/apis/components/power-sensor/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "power_sensor"
+    )
+
+    @abc.abstractmethod
+    async def get_voltage(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Tuple[float, bool]:
+        """Return the voltage reading of a specified device and whether it is AC or DC.
+
+        ::
+
+            my_power_sensor = PowerSensor.from_robot(robot=machine, name='my_power_sensor')
+
+            # Get the voltage reading from the power sensor
+            voltage, is_ac = await my_power_sensor.get_voltage()
+            print("The voltage is", voltage, "V, Is AC:", is_ac)
+
+        Returns:
+            Tuple[float, bool]: A float representing the voltage reading in V. A bool indicating whether the voltage is AC (`true`) or DC
+            (`false`).
+
+        For more information, see `Power Sensor component <https://docs.viam.com/dev/reference/apis/components/power-sensor/#getvoltage>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_current(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Tuple[float, bool]:
+        """Return the current of a specified device and whether it is AC or DC.
+
+        ::
+
+            my_power_sensor = PowerSensor.from_robot(robot=machine, name='my_power_sensor')
+
+            # Get the current reading from the power sensor
+            current, is_ac = await my_power_sensor.get_current()
+            print("The current is ", current, " A, Is AC: ", is_ac)
+
+        Returns:
+            Tuple[float, bool]: A tuple which includes a float representing the current reading in amps, and a bool indicating whether the
+            current is AC (`true`) or DC (`false`).
+
+        For more information, see `Power Sensor component <https://docs.viam.com/dev/reference/apis/components/power-sensor/#getcurrent>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_power(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> float:
+        """Return the power reading in watts.
+
+        ::
+
+            my_power_sensor = PowerSensor.from_robot(robot=machine, name='my_power_sensor')
+
+            # Get the power reading from the power sensor
+            power = await my_power_sensor.get_power()
+            print("The power is", power, "Watts")
+
+        Returns:
+            float: The power reading in watts.
+
+        For more information, see `Power Sensor component <https://docs.viam.com/dev/reference/apis/components/power-sensor/#getpower>`_.
+        """
+        ...
+
+    async def get_readings(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Mapping[str, SensorReading]:
+        """Get the measurements or readings that this power sensor provides. If a sensor is not configured correctly or fails to read a
+        piece of data, it will not appear in the readings dictionary.
+
+        ::
+
+            my_power_sensor = PowerSensor.from_robot(robot=machine, name='my_power_sensor')
+
+            # Get the readings provided by the sensor.
+            readings = await my_power_sensor.get_readings()
+
+        Returns:
+            Mapping[str, Any]: The readings for the PowerSensor. Can be of any type. Includes voltage in volts (float), current in
+                amperes (float), is_ac (bool), and power in watts (float).
+
+        For more information, see `Power Sensor component <https://docs.viam.com/dev/reference/apis/components/power-sensor/#getreadings>`_.
+        """
+        ...

viam/components/power_sensor/service.py

@@ -0,0 +1,72 @@
+from grpclib.server import Stream
+
+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,
+    PowerSensorServiceBase,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, sensor_readings_native_to_value, struct_to_dict
+
+
+class PowerSensorRPCService(PowerSensorServiceBase, ResourceRPCServiceBase[PowerSensor]):
+    """
+    gRPC Service for a PowerSensor
+    """
+
+    RESOURCE_TYPE = PowerSensor
+
+    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)
+
+    async def GetVoltage(self, stream: Stream[GetVoltageRequest, GetVoltageResponse]) -> 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
+        voltage, is_ac = await sensor.get_voltage(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetVoltageResponse(volts=voltage, is_ac=is_ac)
+        await stream.send_message(response)
+
+    async def GetCurrent(self, stream: Stream[GetCurrentRequest, GetCurrentResponse]) -> 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
+        current, is_ac = await sensor.get_current(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetCurrentResponse(amperes=current, is_ac=is_ac)
+        await stream.send_message(response)
+
+    async def GetPower(self, stream: Stream[GetPowerRequest, GetPowerResponse]) -> 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
+        power = await sensor.get_power(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetPowerResponse(watts=power)
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> 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
+        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)

viam/components/sensor/__init__.py

@@ -0,0 +1,18 @@
+import viam.gen.component.sensor.v1.sensor_pb2  # Need this import for Sensor service descriptors to resolve
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import SensorClient
+from .sensor import Sensor
+from .service import SensorRPCService
+
+__all__ = [
+    "Sensor",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        Sensor,
+        SensorRPCService,
+        lambda name, channel: SensorClient(name, channel),
+    )
+)

viam/components/sensor/client.py

@@ -0,0 +1,49 @@
+from typing import Any, Dict, List, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetReadingsRequest, GetReadingsResponse
+from viam.proto.component.sensor import SensorServiceStub
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import SensorReading, ValueTypes, dict_to_struct, get_geometries, sensor_readings_value_to_native, struct_to_dict
+
+from .sensor import Sensor
+
+
+class SensorClient(Sensor, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the Sensor component.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = SensorServiceStub(channel)
+        super().__init__(name)
+
+    async def get_readings(
+        self,
+        *,
+        extra: Optional[Mapping[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)
+
+    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)