viam-sdk 0.45.2__py3-none-win_amd64.whl

viam/components/camera/service.py

@@ -0,0 +1,105 @@
+# TODO: Update type checking based with RSDK-4089
+# pyright: reportGeneralTypeIssues=false
+from google.api.httpbody_pb2 import HttpBody  # type: ignore
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.component.camera import (
+    CameraServiceBase,
+    GetImageRequest,
+    GetImageResponse,
+    GetImagesRequest,
+    GetImagesResponse,
+    GetPointCloudRequest,
+    GetPointCloudResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    Image,
+    RenderFrameRequest,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from . import Camera
+
+
+class CameraRPCService(CameraServiceBase, ResourceRPCServiceBase[Camera]):
+    """
+    gRPC Service for a generic Camera
+    """
+
+    RESOURCE_TYPE = Camera
+
+    async def GetImage(self, stream: Stream[GetImageRequest, GetImageResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        camera = self.get_resource(name)
+
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        image = await camera.get_image(request.mime_type, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetImageResponse(mime_type=image.mime_type, image=image.data)
+        await stream.send_message(response)
+
+    async def GetImages(self, stream: Stream[GetImagesRequest, GetImagesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        camera = self.get_resource(name)
+
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        images, metadata = await camera.get_images(timeout=timeout, metadata=stream.metadata)
+        img_bytes_lst = []
+        for img in images:
+            fmt = img.mime_type.to_proto()
+            img_bytes = img.data
+            img_bytes_lst.append(Image(source_name=name, format=fmt, image=img_bytes))
+        response = GetImagesResponse(images=img_bytes_lst, response_metadata=metadata)
+        await stream.send_message(response)
+
+    async def RenderFrame(self, stream: Stream[RenderFrameRequest, HttpBody]) -> None:  # pyright: ignore [reportInvalidTypeForm]
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        camera = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        image = await camera.get_image(request.mime_type, timeout=timeout, metadata=stream.metadata)
+        response = HttpBody(data=image.data, content_type=image.mime_type)  # type: ignore
+        await stream.send_message(response)
+
+    async def GetPointCloud(self, stream: Stream[GetPointCloudRequest, GetPointCloudResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        camera = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        pc, mimetype = await camera.get_point_cloud(timeout=timeout, extra=struct_to_dict(request.extra), metadata=stream.metadata)
+        response = GetPointCloudResponse(mime_type=mimetype, point_cloud=pc)
+        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
+        camera = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await camera.get_properties(timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(properties)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        camera = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await camera.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
+        camera = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await camera.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/component_base.py

@@ -0,0 +1,65 @@
+import abc
+from logging import Logger
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Mapping, Optional, SupportsBytes, SupportsFloat, Union, cast
+
+from typing_extensions import Self
+
+from viam.errors import MethodNotImplementedError
+from viam.logging import getLogger
+from viam.proto.common import Geometry
+from viam.resource.base import ResourceBase
+
+if TYPE_CHECKING:
+    from viam.resource.types import API
+    from viam.robot.client import RobotClient
+
+
+ValueTypes = Union[bool, SupportsBytes, SupportsFloat, List, Mapping, str, None]
+
+
+class ComponentBase(abc.ABC, ResourceBase):
+    """
+    Base component.
+    All components must inherit from this class.
+    """
+
+    API: ClassVar["API"]
+
+    def __init__(self, name: str, *, logger: Optional[Logger] = None):
+        self.name = name
+        self.logger = logger if logger is not None else getLogger(f"{self.API}.{name}")
+
+    @classmethod
+    def from_robot(cls, robot: "RobotClient", name: str) -> Self:
+        """Get the component named ``name`` from the provided robot.
+
+        Args:
+            robot (RobotClient): The robot
+            name (str): The name of the component
+
+        Returns:
+            Self: The component, if it exists on the robot
+        """
+        component = robot.get_component(cls.get_resource_name(name))
+        return cast(cls, component)  # type: ignore
+
+    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes]:
+        raise NotImplementedError()
+
+    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[Geometry]:
+        """
+        Get all geometries associated with the component, in their current configuration, in the
+        `frame <https://docs.viam.com/operate/mobility/define-geometry/>`__ of the component.
+
+        ::
+
+            geometries = await component.get_geometries()
+
+            if geometries:
+                # Get the center of the first geometry
+                print(f"Pose of the first geometry's centerpoint: {geometries[0].center}")
+
+        Returns:
+            List[Geometry]: The geometries associated with the Component.
+        """
+        raise MethodNotImplementedError("get_geometries")

viam/components/encoder/__init__.py

@@ -0,0 +1,18 @@
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import EncoderClient
+from .encoder import Encoder
+from .service import EncoderRPCService
+
+__all__ = [
+    "Encoder",
+]
+
+
+Registry.register_api(
+    ResourceRegistration(
+        Encoder,
+        EncoderRPCService,
+        lambda name, channel: EncoderClient(name, channel),
+    )
+)

viam/components/encoder/client.py

@@ -0,0 +1,83 @@
+from typing import Any, Dict, List, Mapping, Optional, Tuple
+
+from grpclib.client import Channel
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
+from viam.proto.component.encoder import (
+    EncoderServiceStub,
+    GetPositionRequest,
+    GetPositionResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    PositionType,
+    ResetPositionRequest,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from .encoder import Encoder
+
+
+class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the Encoder component.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = EncoderServiceStub(channel)
+        super().__init__(name)
+
+    async def reset_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = ResetPositionRequest(name=self.name, extra=dict_to_struct(extra))
+        await self.client.ResetPosition(request, timeout=timeout, metadata=md)
+
+    async def get_position(
+        self,
+        position_type: Optional[PositionType.ValueType] = None,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[float, PositionType.ValueType]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPositionRequest(name=self.name, position_type=position_type, extra=dict_to_struct(extra))
+        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout, metadata=md)
+        return response.value, response.position_type
+
+    async def get_properties(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Encoder.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 Encoder.Properties(
+            ticks_count_supported=response.ticks_count_supported, angle_degrees_supported=response.angle_degrees_supported
+        )
+
+    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/encoder/encoder.py

@@ -0,0 +1,118 @@
+import abc
+from dataclasses import dataclass
+from typing import Any, Dict, Final, Optional, Tuple
+
+from viam.proto.component.encoder import PositionType
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from ..component_base import ComponentBase
+
+
+class Encoder(ComponentBase):
+    @dataclass
+    class Properties:
+        ticks_count_supported: bool
+        angle_degrees_supported: bool
+
+    """
+    Encoder represents a physical encoder.
+
+    This acts as an abstract base class for any drivers representing specific
+    encoder implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.encoder import Encoder
+
+    For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "encoder"
+    )
+
+    @abc.abstractmethod
+    async def reset_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Set the current position to be the new zero (home) position.
+
+        ::
+
+            my_encoder = Encoder.from_robot(robot=machine, name='my_encoder')
+
+            # Reset the zero position of the encoder.
+            await my_encoder.reset_position()
+
+
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#resetposition>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_position(
+        self,
+        position_type: Optional[PositionType.ValueType] = None,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[float, PositionType.ValueType]:
+        """
+        Report the position of the encoder.
+        The value returned is the current position in terms of it's ``position_type``.
+        The position will be either in relative units (ticks away from a zero position) for
+        ``PositionType.POSITION_TYPE_TICKS_COUNT`` or absolute units (degrees along a circle)
+        for ``PositionType.POSITION_TYPE_ANGLE_DEGREES``.
+
+        ::
+
+            my_encoder = Encoder.from_robot(robot=machine, name='my_encoder')
+
+            # Get the position of the encoder in ticks
+            position = await my_encoder.get_position(PositionType.POSITION_TYPE_TICKS_COUNT)
+            print("The encoder position is currently ", position[0], position[1])
+
+        Args:
+            position_type (PositionType): The desired output type of the position.
+
+        Returns:
+            Tuple[float, PositionType]:
+            A tuple containing two values; the first [0] the position of the encoder which can either be
+            ticks since last zeroing for a relative encoder or degrees for an absolute encoder, and the second [1] the type of
+            position the encoder returns (ticks or degrees).
+
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#getposition>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_properties(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Properties:
+        """
+        Return a dictionary of the types of position reporting this encoder supports.
+
+        ::
+
+            my_encoder = Encoder.from_robot(robot=machine, name='my_encoder')
+
+            # Get whether the encoder returns position in ticks or degrees.
+            properties = await my_encoder.get_properties()
+
+        Returns:
+            Encoder.Properties: Map of position types to supported status.
+
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#getproperties>`_.
+        """
+        ...

viam/components/encoder/service.py

@@ -0,0 +1,72 @@
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.component.encoder import (
+    EncoderServiceBase,
+    GetPositionRequest,
+    GetPositionResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    ResetPositionRequest,
+    ResetPositionResponse,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .encoder import Encoder
+
+
+class EncoderRPCService(EncoderServiceBase, ResourceRPCServiceBase[Encoder]):
+    """
+    gRPC Service for an Encoder
+    """
+
+    RESOURCE_TYPE = Encoder
+
+    async def ResetPosition(self, stream: Stream[ResetPositionRequest, ResetPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        encoder = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await encoder.reset_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(ResetPositionResponse())
+
+    async def GetPosition(self, stream: Stream[GetPositionRequest, GetPositionResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        encoder = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        position, pos_type = await encoder.get_position(
+            position_type=request.position_type, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
+        )
+        await stream.send_message(GetPositionResponse(value=position, position_type=pos_type))
+
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        encoder = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await encoder.get_properties(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetPropertiesResponse(**properties.__dict__)
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        encoder = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await encoder.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
+        arm = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await arm.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/gantry/__init__.py

@@ -0,0 +1,11 @@
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import GantryClient
+from .gantry import Gantry
+from .service import GantryRPCService
+
+__all__ = [
+    "Gantry",
+]
+
+Registry.register_api(ResourceRegistration(Gantry, GantryRPCService, lambda name, channel: GantryClient(name, channel)))

viam/components/gantry/client.py

@@ -0,0 +1,115 @@
+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.gantry import (
+    GantryServiceStub,
+    GetLengthsRequest,
+    GetLengthsResponse,
+    GetPositionRequest,
+    GetPositionResponse,
+    HomeRequest,
+    HomeResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    MoveToPositionRequest,
+    StopRequest,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from .gantry import Gantry
+
+
+class GantryClient(Gantry, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the Gantry component.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = GantryServiceStub(channel)
+        super().__init__(name)
+
+    async def get_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> List[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 list(response.positions_mm)
+
+    async def move_to_position(
+        self,
+        positions: List[float],
+        speeds: List[float],
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = MoveToPositionRequest(name=self.name, positions_mm=positions, speeds_mm_per_sec=speeds, extra=dict_to_struct(extra))
+        await self.client.MoveToPosition(request, timeout=timeout, metadata=md)
+
+    async def home(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> bool:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = HomeRequest(name=self.name, extra=dict_to_struct(extra))
+        response: HomeResponse = await self.client.Home(request, timeout=timeout, metadata=md)
+        return response.homed
+
+    async def get_lengths(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> List[float]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetLengthsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetLengthsResponse = await self.client.GetLengths(request, timeout=timeout, metadata=md)
+        return list(response.lengths_mm)
+
+    async def stop(
+        self,
+        *,
+        extra: Optional[Dict[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)