viam-sdk 0.45.2__py3-none-win_amd64.whl

viam/components/motor/service.py

@@ -0,0 +1,150 @@
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.component.motor import (
+    GetPositionRequest,
+    GetPositionResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    GoForRequest,
+    GoForResponse,
+    GoToRequest,
+    GoToResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    IsPoweredRequest,
+    IsPoweredResponse,
+    ResetZeroPositionRequest,
+    ResetZeroPositionResponse,
+    SetPowerRequest,
+    SetPowerResponse,
+    SetRPMRequest,
+    SetRPMResponse,
+    StopRequest,
+    StopResponse,
+    UnimplementedMotorServiceBase,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .motor import Motor
+
+
+class MotorRPCService(UnimplementedMotorServiceBase, ResourceRPCServiceBase[Motor]):
+    """
+    gRPC Service for a Motor
+    """
+
+    RESOURCE_TYPE = Motor
+
+    async def SetPower(self, stream: Stream[SetPowerRequest, SetPowerResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await motor.set_power(request.power_pct, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(SetPowerResponse())
+
+    async def GoFor(self, stream: Stream[GoForRequest, GoForResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await motor.go_for(request.rpm, request.revolutions, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(GoForResponse())
+
+    async def GoTo(self, stream: Stream[GoToRequest, GoToResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await motor.go_to(
+            request.rpm, request.position_revolutions, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
+        )
+        await stream.send_message(GoToResponse())
+
+    async def SetRPM(self, stream: Stream[SetRPMRequest, SetRPMResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await motor.set_rpm(request.rpm, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(SetRPMResponse())
+
+    async def ResetZeroPosition(self, stream: Stream[ResetZeroPositionRequest, ResetZeroPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await motor.reset_zero_position(request.offset, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(ResetZeroPositionResponse())
+
+    async def GetPosition(self, stream: Stream[GetPositionRequest, GetPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        position = await motor.get_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(GetPositionResponse(position=position))
+
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await motor.get_properties(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetPropertiesResponse(**properties.__dict__)
+        await stream.send_message(response)
+
+    async def Stop(self, stream: Stream[StopRequest, StopResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await motor.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = StopResponse()
+        await stream.send_message(response)
+
+    async def IsPowered(self, stream: Stream[IsPoweredRequest, IsPoweredResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        is_powered, power_pct = await motor.is_powered(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(IsPoweredResponse(is_on=is_powered, power_pct=power_pct))
+
+    async def IsMoving(self, stream: Stream[IsMovingRequest, IsMovingResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        motor = self.get_resource(name)
+        is_moving = await motor.is_moving()
+        response = IsMovingResponse(is_moving=is_moving)
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        motor = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await motor.do_command(command=struct_to_dict(request.command), timeout=timeout, metadata=stream.metadata)
+        response = DoCommandResponse(result=dict_to_struct(result))
+        await stream.send_message(response)
+
+    async def GetGeometries(self, stream: Stream[GetGeometriesRequest, GetGeometriesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        motor = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await motor.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/movement_sensor/__init__.py

@@ -0,0 +1,21 @@
+from viam.proto.common import GeoPoint, Orientation, Vector3
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import MovementSensorClient
+from .movement_sensor import MovementSensor
+from .service import MovementSensorRPCService
+
+__all__ = [
+    "MovementSensor",
+    "GeoPoint",
+    "Orientation",
+    "Vector3",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        MovementSensor,
+        MovementSensorRPCService,
+        lambda name, channel: MovementSensorClient(name, channel),
+    )
+)

viam/components/movement_sensor/client.py

@@ -0,0 +1,161 @@
+from typing import Any, Dict, List, Mapping, Optional, Tuple
+
+from grpclib.client import Channel
+
+from viam.components.movement_sensor.movement_sensor import MovementSensor
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetReadingsRequest, GetReadingsResponse
+from viam.proto.component.movementsensor import (
+    GetAccuracyRequest,
+    GetAngularVelocityRequest,
+    GetAngularVelocityResponse,
+    GetCompassHeadingRequest,
+    GetCompassHeadingResponse,
+    GetLinearAccelerationRequest,
+    GetLinearAccelerationResponse,
+    GetLinearVelocityRequest,
+    GetLinearVelocityResponse,
+    GetOrientationRequest,
+    GetOrientationResponse,
+    GetPositionRequest,
+    GetPositionResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    MovementSensorServiceStub,
+)
+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 . import GeoPoint, Orientation, Vector3
+
+
+class MovementSensorClient(MovementSensor, ReconfigurableResourceRPCClientBase):
+    """gRPC client for the MovementSensor component."""
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = MovementSensorServiceStub(channel)
+        super().__init__(name)
+
+    async def get_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[GeoPoint, float]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPositionRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout, metadata=md)
+        return response.coordinate, response.altitude_m
+
+    async def get_linear_velocity(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Vector3:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetLinearVelocityRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetLinearVelocityResponse = await self.client.GetLinearVelocity(request, timeout=timeout, metadata=md)
+        return response.linear_velocity
+
+    async def get_angular_velocity(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Vector3:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetAngularVelocityRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetAngularVelocityResponse = await self.client.GetAngularVelocity(request, timeout=timeout, metadata=md)
+        return response.angular_velocity
+
+    async def get_linear_acceleration(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Vector3:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetLinearAccelerationRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetLinearAccelerationResponse = await self.client.GetLinearAcceleration(request, timeout=timeout, metadata=md)
+        return response.linear_acceleration
+
+    async def get_compass_heading(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> float:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetCompassHeadingRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetCompassHeadingResponse = await self.client.GetCompassHeading(request, timeout=timeout, metadata=md)
+        return response.value
+
+    async def get_orientation(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Orientation:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetOrientationRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetOrientationResponse = await self.client.GetOrientation(request, timeout=timeout, metadata=md)
+        return response.orientation
+
+    async def get_properties(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> MovementSensor.Properties:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPropertiesRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetPropertiesResponse = await self.client.GetProperties(request, timeout=timeout, metadata=md)
+        return MovementSensor.Properties.from_proto(response)
+
+    async def get_accuracy(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> MovementSensor.Accuracy:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetAccuracyRequest(name=self.name, extra=dict_to_struct(extra))
+        return await self.client.GetAccuracy(request, timeout=timeout, metadata=md)
+
+    async def get_readings(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, SensorReading]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetReadingsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetReadingsResponse = await self.client.GetReadings(request, timeout=timeout, metadata=md)
+
+        return sensor_readings_value_to_native(response.readings)
+
+    async def do_command(
+        self,
+        command: Mapping[str, ValueTypes],
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, ValueTypes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = DoCommandRequest(name=self.name, command=dict_to_struct(command))
+        response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout, 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/movement_sensor/movement_sensor.py

@@ -0,0 +1,253 @@
+import abc
+import sys
+from dataclasses import dataclass
+from typing import Any, Dict, Final, Mapping, Optional, Tuple
+
+from typing_extensions import Self
+
+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 . import GeoPoint, Orientation, Vector3
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+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/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "movement_sensor"
+    )
+
+    Accuracy: "TypeAlias" = GetAccuracyResponse
+
+    @dataclass
+    class Properties:
+        linear_acceleration_supported: bool
+        angular_velocity_supported: bool
+        orientation_supported: bool
+        position_supported: bool
+        compass_heading_supported: bool
+        linear_velocity_supported: bool
+
+        @property
+        def proto(self) -> GetPropertiesResponse:
+            return GetPropertiesResponse(
+                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_velocity_supported,
+            )
+
+        @classmethod
+        def from_proto(cls, proto: GetPropertiesResponse) -> Self:
+            return cls(
+                linear_acceleration_supported=proto.linear_acceleration_supported,
+                angular_velocity_supported=proto.angular_velocity_supported,
+                orientation_supported=proto.orientation_supported,
+                position_supported=proto.position_supported,
+                compass_heading_supported=proto.compass_heading_supported,
+                linear_velocity_supported=proto.linear_velocity_supported,
+            )
+
+    @abc.abstractmethod
+    async def get_position(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> 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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_linear_acceleration(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> 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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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) -> 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:
+            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, 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. Can be of any type.
+
+        For more information, see `Movement Sensor component <https://docs.viam.com/dev/reference/apis/components/movement-sensor/#getreadings>`_.
+        """
+        ...