viam-sdk 0.45.2__py3-none-win_amd64.whl

viam/components/board/service.py

@@ -0,0 +1,223 @@
+from grpclib.server import Stream
+from h2.exceptions import StreamClosedError
+
+from viam.errors import ResourceNotFoundError
+from viam.logging import getLogger
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.component.board import (
+    BoardServiceBase,
+    GetDigitalInterruptValueRequest,
+    GetDigitalInterruptValueResponse,
+    GetGPIORequest,
+    GetGPIOResponse,
+    PWMFrequencyRequest,
+    PWMFrequencyResponse,
+    PWMRequest,
+    PWMResponse,
+    ReadAnalogReaderRequest,
+    ReadAnalogReaderResponse,
+    SetGPIORequest,
+    SetGPIOResponse,
+    SetPowerModeRequest,
+    SetPowerModeResponse,
+    SetPWMFrequencyRequest,
+    SetPWMFrequencyResponse,
+    SetPWMRequest,
+    SetPWMResponse,
+    StreamTicksRequest,
+    StreamTicksResponse,
+    WriteAnalogRequest,
+    WriteAnalogResponse,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .board import Board
+
+LOGGER = getLogger(__name__)
+
+
+class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
+    """
+    gRPC Service for a Board
+    """
+
+    RESOURCE_TYPE = Board
+
+    async def SetGPIO(self, stream: Stream[SetGPIORequest, SetGPIOResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        try:
+            pin = await board.gpio_pin_by_name(request.pin)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await pin.set(request.high, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = SetGPIOResponse()
+        await stream.send_message(response)
+
+    async def GetGPIO(self, stream: Stream[GetGPIORequest, GetGPIOResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        try:
+            pin = await board.gpio_pin_by_name(request.pin)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        high = await pin.get(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetGPIOResponse(high=high)
+        await stream.send_message(response)
+
+    async def PWM(self, stream: Stream[PWMRequest, PWMResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        try:
+            pin = await board.gpio_pin_by_name(request.pin)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        pwm = await pin.get_pwm(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = PWMResponse(duty_cycle_pct=pwm)
+        await stream.send_message(response)
+
+    async def SetPWM(self, stream: Stream[SetPWMRequest, SetPWMResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        try:
+            pin = await board.gpio_pin_by_name(request.pin)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await pin.set_pwm(request.duty_cycle_pct, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = SetPWMResponse()
+        await stream.send_message(response)
+
+    async def PWMFrequency(self, stream: Stream[PWMFrequencyRequest, PWMFrequencyResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        try:
+            pin = await board.gpio_pin_by_name(request.pin)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        frequency = await pin.get_pwm_frequency(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = PWMFrequencyResponse(frequency_hz=frequency)
+        await stream.send_message(response)
+
+    async def SetPWMFrequency(self, stream: Stream[SetPWMFrequencyRequest, SetPWMFrequencyResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        try:
+            pin = await board.gpio_pin_by_name(request.pin)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await pin.set_pwm_frequency(request.frequency_hz, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = SetPWMFrequencyResponse()
+        await stream.send_message(response)
+
+    async def ReadAnalogReader(self, stream: Stream[ReadAnalogReaderRequest, ReadAnalogReaderResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.board_name
+        board = self.get_resource(name)
+        try:
+            analog_reader = await board.analog_by_name(request.analog_reader_name)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        response = await analog_reader.read(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(response)
+
+    async def GetDigitalInterruptValue(self, stream: Stream[GetDigitalInterruptValueRequest, GetDigitalInterruptValueResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.board_name
+        board = self.get_resource(name)
+        try:
+            interrupt = await board.digital_interrupt_by_name(request.digital_interrupt_name)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        value = await interrupt.value(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetDigitalInterruptValueResponse(value=value)
+        await stream.send_message(response)
+
+    async def SetPowerMode(self, stream: Stream[SetPowerModeRequest, SetPowerModeResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await board.set_power_mode(
+            mode=request.power_mode,
+            duration=request.duration.ToTimedelta(),
+            timeout=timeout,
+            metadata=stream.metadata,
+        )
+        response = SetPowerModeResponse()
+        await stream.send_message(response)
+
+    async def WriteAnalog(self, stream: Stream[WriteAnalogRequest, WriteAnalogResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+        try:
+            analog_writer = await board.analog_by_name(request.pin)
+        except ResourceNotFoundError as e:
+            raise e.grpc_error
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await analog_writer.write(value=request.value, timeout=timeout, metadata=stream.metadata, extra=struct_to_dict(request.extra))
+        response = WriteAnalogResponse()
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        board = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await board.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)
+
+    async def StreamTicks(self, stream: Stream[StreamTicksRequest, StreamTicksResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        board = self.get_resource(name)
+
+        dis = []
+        for name in request.pin_names:
+            dis.append(await board.digital_interrupt_by_name(name))
+
+        tick_stream = await board.stream_ticks(interrupts=dis, metadata=stream.metadata)
+        async for tick in tick_stream:
+            try:
+                await stream.send_message(tick)
+            except StreamClosedError:
+                return
+            except Exception as e:
+                LOGGER.error(e)
+                return

viam/components/button/__init__.py

@@ -0,0 +1,10 @@
+import viam.gen.component.button.v1.button_pb2
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .button import Button
+from .client import ButtonClient
+from .service import ButtonRPCService
+
+__all__ = ["Button"]
+
+Registry.register_api(ResourceRegistration(Button, ButtonRPCService, lambda name, channel: ButtonClient(name, channel)))

viam/components/button/button.py

@@ -0,0 +1,41 @@
+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 Button(ComponentBase):
+    """
+    Button represents a device that can be pushed.
+
+    This acts as an abstract base class for any drivers representing specific
+    button implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.button import Button
+
+    For more information, see `Button component <https://docs.viam.com/dev/reference/apis/components/button/>` _.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "button"
+    )
+
+    @abc.abstractmethod
+    async def push(self, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> None:
+        """
+        Push the button.
+
+        ::
+
+            my_button = Button.from_robot(robot=machine, name="my_button")
+
+            # Push the button
+            await my_button.push()
+
+        For more information, see `Button component <https://docs.viam.com/dev/reference/apis/components/button/>` _.
+        """
+        ...

viam/components/button/client.py

@@ -0,0 +1,52 @@
+from typing import Any, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.gen.component.button.v1.button_pb2 import PushRequest
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.button import ButtonServiceStub
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import (
+    ValueTypes,
+    dict_to_struct,
+    struct_to_dict,
+)
+
+from .button import Button
+
+
+class ButtonClient(Button, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for Button component
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = ButtonServiceStub(channel)
+        super().__init__(name)
+
+    async def push(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> None:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = PushRequest(name=self.name, extra=dict_to_struct(extra))
+        await self.client.Push(request, timeout=timeout, metadata=md)
+
+    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/button/service.py

@@ -0,0 +1,46 @@
+from grpclib.server import Stream
+
+from viam.gen.component.button.v1.button_pb2 import (
+    PushRequest,
+    PushResponse,
+)
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.button import ButtonServiceBase
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .button import Button
+
+
+class ButtonRPCService(ButtonServiceBase, ResourceRPCServiceBase[Button]):
+    """
+    gRPC Service for a generic Button
+    """
+
+    RESOURCE_TYPE = Button
+
+    async def Push(self, stream: Stream[PushRequest, PushResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        button = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await button.push(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(PushResponse())
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        button = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await button.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/camera/__init__.py

@@ -0,0 +1,22 @@
+from viam.media.video import ViamImage
+from viam.proto.component.camera import DistortionParameters, IntrinsicParameters
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .camera import Camera
+from .client import CameraClient
+from .service import CameraRPCService
+
+__all__ = [
+    "Camera",
+    "IntrinsicParameters",
+    "DistortionParameters",
+    "ViamImage",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        Camera,
+        CameraRPCService,
+        lambda name, channel: CameraClient(name, channel),
+    )
+)

viam/components/camera/camera.py

@@ -0,0 +1,138 @@
+import abc
+import sys
+from typing import Any, Dict, Final, List, Optional, Tuple
+
+from viam.media.video import NamedImage, ViamImage
+from viam.proto.common import ResponseMetadata
+from viam.proto.component.camera import GetPropertiesResponse
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from ..component_base import ComponentBase
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+class Camera(ComponentBase):
+    """
+    Camera represents any physical hardware that can capture frames.
+
+    This acts as an abstract base class for any drivers representing specific
+    camera implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.camera import Camera
+
+    For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "camera"
+    )
+
+    Properties: "TypeAlias" = GetPropertiesResponse
+
+    @abc.abstractmethod
+    async def get_image(
+        self, mime_type: str = "", *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> ViamImage:
+        """Get the next image from the camera as a ViamImage.
+        Be sure to close the image when finished.
+
+        NOTE: If the mime type is ``image/vnd.viam.dep`` you can use :func:`viam.media.video.ViamImage.bytes_to_depth_array`
+        to convert the data to a standard representation.
+
+        ::
+
+            my_camera = Camera.from_robot(machine, "my_camera")
+            frame = await my_camera.get_image()
+            print(f"Frame: {frame}")
+
+        Args:
+            mime_type (str): The desired mime type of the image. This does not guarantee output type
+
+        Returns:
+            ViamImage: The frame.
+
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getimage>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_images(self, *, timeout: Optional[float] = None, **kwargs) -> Tuple[List[NamedImage], ResponseMetadata]:
+        """Get simultaneous images from different imagers, along with associated metadata.
+        This should not be used for getting a time series of images from the same imager.
+
+        ::
+
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
+
+            images, metadata = await my_camera.get_images()
+            first_image = images[0]
+            timestamp = metadata.captured_at
+
+        Returns:
+            Tuple[List[NamedImage], ResponseMetadata]: A tuple containing two values; the first [0] a list of images
+            returned from the camera system, and the second [1] the metadata associated with this response.
+
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getimages>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_point_cloud(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Tuple[bytes, str]:
+        """
+        Get the next point cloud from the camera. This will be
+        returned as bytes with a mimetype describing
+        the structure of the data. The consumer of this call
+        should encode the bytes into the formatted suggested
+        by the mimetype.
+
+        To deserialize the returned information into a numpy array, use the Open3D library.
+
+        ::
+
+            import numpy as np
+            import open3d as o3d
+
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
+
+            data, _ = await my_camera.get_point_cloud()
+
+            # write the point cloud into a temporary file
+            with open("/tmp/pointcloud_data.pcd", "wb") as f:
+                f.write(data)
+            pcd = o3d.io.read_point_cloud("/tmp/pointcloud_data.pcd")
+            points = np.asarray(pcd.points)
+
+        Returns:
+            Tuple[bytes, str]: A tuple containing two values; the first [0] the pointcloud data,
+            and the second [1] the mimetype of the pointcloud (for example, PCD).
+
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getpointcloud>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> Properties:
+        """
+        Get the camera intrinsic parameters and camera distortion parameters
+
+        ::
+
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
+
+            properties = await my_camera.get_properties()
+
+        Returns:
+            Properties: The properties of the camera.
+
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getproperties>`_.
+        """
+        ...

viam/components/camera/client.py

@@ -0,0 +1,98 @@
+from typing import Any, Dict, List, Mapping, Optional, Tuple
+
+from grpclib.client import Channel
+
+from viam.media.video import CameraMimeType, NamedImage, ViamImage
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, ResponseMetadata
+from viam.proto.component.camera import (
+    CameraServiceStub,
+    GetImageRequest,
+    GetImageResponse,
+    GetImagesRequest,
+    GetImagesResponse,
+    GetPointCloudRequest,
+    GetPointCloudResponse,
+    GetPropertiesRequest,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from . import Camera
+
+
+class CameraClient(Camera, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the Camera component
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = CameraServiceStub(channel)
+        super().__init__(name)
+
+    async def get_image(
+        self,
+        mime_type: str = "",
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> ViamImage:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetImageRequest(name=self.name, mime_type=mime_type, extra=dict_to_struct(extra))
+        response: GetImageResponse = await self.client.GetImage(request, timeout=timeout, metadata=md)
+        return ViamImage(response.image, CameraMimeType.from_string(response.mime_type))
+
+    async def get_images(
+        self,
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[List[NamedImage], ResponseMetadata]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetImagesRequest(name=self.name)
+        response: GetImagesResponse = await self.client.GetImages(request, timeout=timeout, metadata=md)
+        imgs = []
+        for img_data in response.images:
+            mime_type = CameraMimeType.from_proto(img_data.format)
+            img = NamedImage(img_data.source_name, img_data.image, mime_type)
+            imgs.append(img)
+        resp_metadata: ResponseMetadata = response.response_metadata
+        return imgs, resp_metadata
+
+    async def get_point_cloud(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[bytes, str]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPointCloudRequest(name=self.name, mime_type=CameraMimeType.PCD, extra=dict_to_struct(extra))
+        response: GetPointCloudResponse = await self.client.GetPointCloud(request, timeout=timeout, metadata=md)
+        return (response.point_cloud, response.mime_type)
+
+    async def get_properties(
+        self,
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Camera.Properties:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        return await self.client.GetProperties(GetPropertiesRequest(name=self.name), timeout=timeout, metadata=md)
+
+    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)