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

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

@@ -1,3 +1,4 @@
+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
@@ -8,7 +9,7 @@ __all__ = [
     "Sensor",
 ]
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         Sensor,
         SensorRPCService,

viam/components/sensor/client.py

@@ -1,11 +1,11 @@
-from typing import Any, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse
-from viam.proto.component.sensor import GetReadingsRequest, GetReadingsResponse, SensorServiceStub
+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 ValueTypes, dict_to_struct, sensor_readings_value_to_native, struct_to_dict
+from viam.utils import SensorReading, ValueTypes, dict_to_struct, get_geometries, sensor_readings_value_to_native, struct_to_dict
 
 from .sensor import Sensor
 
@@ -20,14 +20,30 @@ class SensorClient(Sensor, ReconfigurableResourceRPCClientBase):
         self.client = SensorServiceStub(channel)
         super().__init__(name)
 
-    async def get_readings(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None) -> Mapping[str, Any]:
-        if extra is None:
-            extra = {}
+    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)
+        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) -> 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/sensor/sensor.py

@@ -1,7 +1,8 @@
 import abc
-from typing import Any, Mapping, Optional
+from typing import Any, Final, Mapping, Optional
 
-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 viam.utils import SensorReading
 
 from ..component_base import ComponentBase
 
@@ -13,18 +14,35 @@ class Sensor(ComponentBase):
     This acts as an abstract base class for any drivers representing specific
     sensor implementations. This cannot be used on its own. If the ``__init__()`` function is
     overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.sensor import Sensor
+
+    For more information, see `Sensor component <https://docs.viam.com/dev/reference/apis/components/sensor/>`_.
     """
 
-    SUBTYPE = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "sensor")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "sensor"
+    )
 
     @abc.abstractmethod
     async def get_readings(
         self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs
-    ) -> Mapping[str, Any]:
+    ) -> Mapping[str, SensorReading]:
         """
         Obtain the measurements/data specific to this sensor.
 
+        ::
+
+            my_sensor = Sensor.from_robot(robot=machine, name='my_sensor')
+
+            # Get the readings provided by the sensor.
+            readings = await my_sensor.get_readings()
+
         Returns:
             Mapping[str, Any]: The measurements. Can be of any type.
+
+        For more information, see `Sensor component <https://docs.viam.com/dev/reference/apis/components/sensor/#getreadings>`_.
         """
         ...

viam/components/sensor/service.py

@@ -1,8 +1,14 @@
 from grpclib.server import Stream
 
-from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
-from viam.proto.component.sensor import GetReadingsRequest, GetReadingsResponse, SensorServiceBase
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetReadingsRequest,
+    GetReadingsResponse,
+)
+from viam.proto.component.sensor import SensorServiceBase
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, sensor_readings_native_to_value, struct_to_dict
 
@@ -20,10 +26,7 @@ class SensorRPCService(SensorServiceBase, ResourceRPCServiceBase[Sensor]):
         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
         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))
@@ -32,11 +35,17 @@ class SensorRPCService(SensorServiceBase, ResourceRPCServiceBase[Sensor]):
     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)

viam/components/servo/__init__.py

@@ -1,9 +1,4 @@
-import asyncio
-
-from viam.proto.component.servo import Status as ServoStatus
-from viam.proto.robot import Status
 from viam.resource.registry import Registry, ResourceRegistration
-from viam.utils import message_to_struct
 
 from .client import ServoClient
 from .service import ServoRPCService
@@ -13,11 +8,4 @@ __all__ = [
     "Servo",
 ]
 
-
-async def create_status(component: Servo) -> Status:
-    (position_deg, is_moving) = await asyncio.gather(component.get_position(), component.is_moving())
-    s = ServoStatus(position_deg=position_deg, is_moving=is_moving)
-    return Status(name=Servo.get_resource_name(component.name), status=message_to_struct(s))
-
-
-Registry.register_subtype(ResourceRegistration(Servo, ServoRPCService, lambda name, channel: ServoClient(name, channel), create_status))
+Registry.register_api(ResourceRegistration(Servo, ServoRPCService, lambda name, channel: ServoClient(name, channel)))

viam/components/servo/client.py

@@ -1,8 +1,8 @@
-from typing import Any, Dict, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
 from viam.proto.component.servo import (
     GetPositionRequest,
     GetPositionResponse,
@@ -13,7 +13,7 @@ from viam.proto.component.servo 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 .servo import Servo
 
@@ -28,33 +28,59 @@ class ServoClient(Servo, ReconfigurableResourceRPCClientBase):
         self.client = ServoServiceStub(channel)
         super().__init__(name)
 
-    async def get_position(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None) -> int:
-        if extra is None:
-            extra = {}
+    async def get_position(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> int:
+        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.position_deg
 
-    async def move(self, angle: int, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def move(
+        self,
+        angle: int,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = MoveRequest(name=self.name, angle_deg=angle, extra=dict_to_struct(extra))
-        await self.client.Move(request, timeout=timeout)
+        await self.client.Move(request, timeout=timeout, metadata=md)
 
-    async def stop(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def stop(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = StopRequest(name=self.name, extra=dict_to_struct(extra))
-        await self.client.Stop(request, timeout=timeout)
+        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(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/servo/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.servo import (
     GetPositionRequest,
     GetPositionResponse,
@@ -30,10 +29,7 @@ class ServoRPCService(ServoServiceBase, ResourceRPCServiceBase[Servo]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            servo = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        servo = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await servo.move(request.angle_deg, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(MoveResponse())
@@ -42,10 +38,7 @@ class ServoRPCService(ServoServiceBase, ResourceRPCServiceBase[Servo]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            servo = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        servo = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         position = await servo.get_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         resp = GetPositionResponse(position_deg=position)
@@ -55,10 +48,7 @@ class ServoRPCService(ServoServiceBase, ResourceRPCServiceBase[Servo]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            servo = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        servo = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await servo.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(StopResponse())
@@ -67,21 +57,24 @@ class ServoRPCService(ServoServiceBase, ResourceRPCServiceBase[Servo]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            servo = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        servo = self.get_resource(name)
         is_moving = await servo.is_moving()
         await stream.send_message(IsMovingResponse(is_moving=is_moving))
 
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            servo = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        servo = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await servo.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
+        servo = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await servo.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/servo/servo.py

@@ -1,7 +1,7 @@
 import abc
 from typing import Any, Final, Mapping, Optional
 
-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,17 +13,37 @@ class Servo(ComponentBase):
     This acts as an abstract base class for any drivers representing specific
     servo implementations. This cannot be used on its own. If the ``__init__()`` function is
     overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.servo import Servo
+
+    For more information, see `Servo component <https://docs.viam.com/dev/reference/apis/components/servo/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "servo")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "servo"
+    )
 
     @abc.abstractmethod
     async def move(self, angle: int, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs):
         """
         Move the servo to the provided angle.
 
+        ::
+
+            my_servo = Servo.from_robot(robot=machine, name="my_servo")
+
+            # Move the servo from its origin to the desired angle of 10 degrees.
+            await my_servo.move(10)
+
+            # Move the servo from its origin to the desired angle of 90 degrees.
+            await my_servo.move(90)
+
         Args:
             angle (int): The desired angle of the servo in degrees.
+
+        For more information, see `Servo component <https://docs.viam.com/dev/reference/apis/components/servo/#move>`_.
         """
         ...
 
@@ -32,8 +52,26 @@ class Servo(ComponentBase):
         """
         Get the current angle (degrees) of the servo.
 
+        ::
+
+            my_servo = Servo.from_robot(robot=machine, name="my_servo")
+
+            # Move the servo from its origin to the desired angle of 10 degrees.
+            await my_servo.move(10)
+
+            # Get the current set angle of the servo.
+            pos1 = await my_servo.get_position()
+
+            # Move the servo from its origin to the desired angle of 20 degrees.
+            await my_servo.move(20)
+
+            # Get the current set angle of the servo.
+            pos2 = await my_servo.get_position()
+
         Returns:
             int: The current angle of the servo in degrees.
+
+        For more information, see `Servo component <https://docs.viam.com/dev/reference/apis/components/servo/#getposition>`_.
         """
         ...
 
@@ -41,6 +79,18 @@ class Servo(ComponentBase):
     async def stop(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs):
         """
         Stop the servo. It is assumed that the servo stops immediately.
+
+        ::
+
+            my_servo = Servo.from_robot(robot=machine, name="my_servo")
+
+            # Move the servo from its origin to the desired angle of 10 degrees.
+            await my_servo.move(10)
+
+            # Stop the servo. It is assumed that the servo stops moving immediately.
+            await my_servo.stop()
+
+        For more information, see `Servo component <https://docs.viam.com/dev/reference/apis/components/servo/#stop>`_.
         """
         ...
 
@@ -49,7 +99,16 @@ class Servo(ComponentBase):
         """
         Get if the servo is currently moving.
 
+        ::
+
+            my_servo = Servo.from_robot(robot=machine, name="my_servo")
+
+            print(await my_servo.is_moving())
+
+
         Returns:
             bool: Whether the servo is moving.
+
+        For more information, see `Servo component <https://docs.viam.com/dev/reference/apis/components/servo/#ismoving>`_.
         """
         ...

viam/components/switch/__init__.py

@@ -0,0 +1,10 @@
+import viam.gen.component.switch.v1.switch_pb2
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import SwitchClient
+from .service import SwitchRPCService
+from .switch import Switch
+
+__all__ = ["Switch"]
+
+Registry.register_api(ResourceRegistration(Switch, SwitchRPCService, lambda name, channel: SwitchClient(name, channel)))