viam-sdk 0.45.2__py3-none-win_amd64.whl

viam/components/sensor/sensor.py

@@ -0,0 +1,48 @@
+import abc
+from typing import Any, Final, Mapping, Optional
+
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+from viam.utils import SensorReading
+
+from ..component_base import ComponentBase
+
+
+class Sensor(ComponentBase):
+    """
+    Sensor represents a physical sensing device that can provide measurement readings.
+
+    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/>`_.
+    """
+
+    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, 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

@@ -0,0 +1,51 @@
+from grpclib.server import Stream
+
+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
+
+from .sensor import Sensor
+
+
+class SensorRPCService(SensorServiceBase, ResourceRPCServiceBase[Sensor]):
+    """
+    gRPC Service for a generic Sensor
+    """
+
+    RESOURCE_TYPE = Sensor
+
+    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 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)

viam/components/servo/__init__.py

@@ -0,0 +1,11 @@
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import ServoClient
+from .service import ServoRPCService
+from .servo import Servo
+
+__all__ = [
+    "Servo",
+]
+
+Registry.register_api(ResourceRegistration(Servo, ServoRPCService, lambda name, channel: ServoClient(name, channel)))

viam/components/servo/client.py

@@ -0,0 +1,86 @@
+from typing import Any, Dict, List, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
+from viam.proto.component.servo import (
+    GetPositionRequest,
+    GetPositionResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    MoveRequest,
+    ServoServiceStub,
+    StopRequest,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from .servo import Servo
+
+
+class ServoClient(Servo, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the Servo component.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = ServoServiceStub(channel)
+        super().__init__(name)
+
+    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, metadata=md)
+        return response.position_deg
+
+    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, metadata=md)
+
+    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, metadata=md)
+
+    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, metadata=md)
+        return response.is_moving
+
+    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/servo/service.py

@@ -0,0 +1,80 @@
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.component.servo import (
+    GetPositionRequest,
+    GetPositionResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    MoveRequest,
+    MoveResponse,
+    ServoServiceBase,
+    StopRequest,
+    StopResponse,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .servo import Servo
+
+
+class ServoRPCService(ServoServiceBase, ResourceRPCServiceBase[Servo]):
+    """
+    gRPC Service for a Servo
+    """
+
+    RESOURCE_TYPE = Servo
+
+    async def Move(self, stream: Stream[MoveRequest, MoveResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        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())
+
+    async def GetPosition(self, stream: Stream[GetPositionRequest, GetPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        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)
+        await stream.send_message(resp)
+
+    async def Stop(self, stream: Stream[StopRequest, StopResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        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())
+
+    async def IsMoving(self, stream: Stream[IsMovingRequest, IsMovingResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        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
+        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

@@ -0,0 +1,114 @@
+import abc
+from typing import Any, Final, Mapping, Optional
+
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from ..component_base import ComponentBase
+
+
+class Servo(ComponentBase):
+    """
+    Servo represents a physical servo.
+
+    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/>`_.
+    """
+
+    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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_position(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> int:
+        """
+        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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def is_moving(self) -> bool:
+        """
+        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)))

viam/components/switch/client.py

@@ -0,0 +1,83 @@
+from typing import Any, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.gen.component.switch.v1.switch_pb2 import (
+    GetNumberOfPositionsRequest,
+    GetNumberOfPositionsResponse,
+    GetPositionRequest,
+    GetPositionResponse,
+    SetPositionRequest,
+)
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.switch import SwitchServiceStub
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import (
+    ValueTypes,
+    dict_to_struct,
+    struct_to_dict,
+)
+
+from .switch import Switch
+
+
+class SwitchClient(Switch, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for Switch component
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = SwitchServiceStub(channel)
+        super().__init__(name)
+
+    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, metadata=md)
+        return response.position
+
+    async def set_position(
+        self,
+        position: int,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> None:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = SetPositionRequest(name=self.name, position=position, extra=dict_to_struct(extra))
+        await self.client.SetPosition(request, timeout=timeout, metadata=md)
+
+    async def get_number_of_positions(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> int:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetNumberOfPositionsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetNumberOfPositionsResponse = await self.client.GetNumberOfPositions(request, timeout=timeout, metadata=md)
+        return response.number_of_positions
+
+    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/switch/service.py

@@ -0,0 +1,72 @@
+from grpclib.server import Stream
+
+from viam.gen.component.switch.v1.switch_pb2 import (
+    GetNumberOfPositionsRequest,
+    GetNumberOfPositionsResponse,
+    GetPositionRequest,
+    GetPositionResponse,
+    SetPositionRequest,
+    SetPositionResponse,
+)
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.switch import SwitchServiceBase
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .switch import Switch
+
+
+class SwitchRPCService(SwitchServiceBase, ResourceRPCServiceBase[Switch]):
+    """
+    gRPC Service for a generic Switch
+    """
+
+    RESOURCE_TYPE = Switch
+
+    async def GetPosition(self, stream: Stream[GetPositionRequest, GetPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        switch = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        position = await switch.get_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetPositionResponse(position=position)
+        await stream.send_message(response)
+
+    async def SetPosition(self, stream: Stream[SetPositionRequest, SetPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        switch = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await switch.set_position(position=request.position, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(SetPositionResponse())
+
+    async def GetNumberOfPositions(self, stream: Stream[GetNumberOfPositionsRequest, GetNumberOfPositionsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        switch = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        number_of_positions = await switch.get_number_of_positions(
+            extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
+        )
+        response = GetNumberOfPositionsResponse(number_of_positions=number_of_positions)
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        switch = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await switch.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/switch/switch.py

@@ -0,0 +1,95 @@
+import abc
+from typing import Any, Final, Mapping, Optional
+
+from viam.components.component_base import ComponentBase
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+
+class Switch(ComponentBase):
+    """
+    Switch represents a device with two or more finite states (or positions) than can be set and retrieved.
+
+    This acts as an abstract base class for any drivers representing specific
+    switch implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.switch import Switch
+
+    For more information, see `Switch component <https://docs.viam.com/dev/reference/apis/components/switch/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "switch"
+    )
+
+    @abc.abstractmethod
+    async def get_position(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> int:
+        """
+        Get the current position of the switch
+
+        ::
+
+            my_switch = Switch.from_robot(robot=machine, name="my_switch")
+
+            # Update the switch from its current position to the desired position of 1.
+            await my_switch.set_position(1)
+
+            # Get the current set position of the switch.
+            pos1 = await my_switch.get_position()
+
+            # Update the switch from its current position to the desired position.
+            await my_switch.set_position(0)
+
+            # Get the current set position of the switch.
+            pos2 = await my_switch.get_position()
+
+        Returns:
+            int: The current position of the switch within the range of available positions.
+
+        For more information, see `Switch component <https://docs.viam.com/dev/reference/apis/components/Switch/#getposition>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def set_position(
+        self, position: int, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> None:
+        """
+        Sets the current position of the switch.
+
+        ::
+
+            my_switch = Switch.from_robot(robot=machine, name="my_switch")
+
+            # Update the switch from its current position to the desired position of 1.
+            await my_switch.set_position(1)
+
+            # Update the switch from its current position to the desired position of 0.
+            await my_switch.set_position(0)
+
+        Args:
+            position (int): The position of the switch within the range of available positions.
+
+        For more information, see `Switch component <https://docs.viam.com/dev/reference/apis/components/switch/#setposition>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_number_of_positions(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> int:
+        """
+        Get the number of available positions on the switch.
+
+        ::
+
+            my_switch = Switch.from_robot(robot=machine, name="my_switch")
+
+            print(await my_switch.get_number_of_positions())
+
+        Returns:
+            int: The number of available positions.
+
+        For more information, see `Switch component <https://docs.viam.com/dev/reference/apis/components/switch/#getnumberofpositions>`_.
+        """
+        ...