viam-sdk 0.45.2__py3-none-win_amd64.whl

viam/components/audio_input/service.py

@@ -0,0 +1,114 @@
+import wave
+from datetime import timedelta
+from io import BytesIO
+
+from google.api.httpbody_pb2 import HttpBody  # type: ignore
+from grpclib import GRPCError, Status
+from grpclib.server import Stream
+
+from viam.errors import NotSupportedError
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.component.audioinput import (
+    AudioInputServiceBase,
+    ChunksRequest,
+    ChunksResponse,
+    PropertiesRequest,
+    PropertiesResponse,
+    RecordRequest,
+    SampleFormat,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .audio_input import AudioInput
+
+
+class AudioInputRPCService(AudioInputServiceBase, ResourceRPCServiceBase[AudioInput]):
+    """
+    gRPC Service for a generic AudioInput
+    """
+
+    RESOURCE_TYPE = AudioInput
+
+    async def Chunks(self, stream: Stream[ChunksRequest, ChunksResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        audio_input = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        audio_stream = await audio_input.stream(timeout=timeout, metadata=stream.metadata)
+        first_chunk = await audio_stream.__anext__()
+        await stream.send_message(ChunksResponse(info=first_chunk.info))
+        await stream.send_message(ChunksResponse(chunk=first_chunk.chunk))
+
+        async for audio in audio_stream:
+            await stream.send_message(ChunksResponse(chunk=audio.chunk))
+
+    async def Properties(self, stream: Stream[PropertiesRequest, PropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        audio_input = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        response = (await audio_input.get_properties(timeout=timeout, metadata=stream.metadata)).proto
+        await stream.send_message(response)
+
+    async def Record(self, stream: Stream[RecordRequest, HttpBody]) -> None:  # pyright: ignore [reportInvalidTypeForm]
+        raise NotSupportedError("Recording audio input is not supported").grpc_error
+
+        # TODO: Eventually implement recording
+        request = await stream.recv_message()
+        assert request is not None
+        duration = request.duration.ToTimedelta()
+        if duration.total_seconds() == 0:
+            duration = timedelta(seconds=1)
+        if duration.total_seconds() > 5:
+            raise GRPCError(Status.INVALID_ARGUMENT, "Can only record up to 5 seconds")
+
+        audio_input = self.get_resource(request.name)
+        audio_stream = await audio_input.stream()
+        first_chunk = await audio_stream.__anext__()
+        num_chunks = int(duration.total_seconds() * float(first_chunk.info.sampling_rate / first_chunk.chunk.length))
+
+        sample_width: int
+        if first_chunk.info.sample_format == SampleFormat.SAMPLE_FORMAT_INT16_INTERLEAVED:
+            sample_width = 2
+        elif first_chunk.info.sample_format == SampleFormat.SAMPLE_FORMAT_FLOAT32_INTERLEAVED:
+            sample_width = 4
+        else:
+            raise GRPCError(Status.INVALID_ARGUMENT, "Unspecified type of audio buffer")
+
+        output = BytesIO()
+        wav_file = wave.open(output, "w")
+        wav_file.setnchannels(first_chunk.info.channels)
+        wav_file.setframerate(first_chunk.info.sampling_rate)
+        wav_file.setsampwidth(sample_width)
+        try:
+            wav_file.writeframes(first_chunk.chunk.data)
+            for _ in range(num_chunks - 1):
+                chunk = await audio_stream.__anext__()
+                wav_file.writeframes(chunk.chunk.data)
+        finally:
+            wav_file.close()
+            output.close()
+
+        output.seek(0)
+        response = HttpBody(data=output.read(), content_type="audio/wav")
+
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        audio_input = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await audio_input.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
+        audio_input = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await audio_input.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/base/__init__.py

@@ -0,0 +1,13 @@
+from viam.proto.common import Vector3
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .base import Base
+from .client import BaseClient
+from .service import BaseRPCService
+
+__all__ = [
+    "Base",
+    "Vector3",
+]
+
+Registry.register_api(ResourceRegistration(Base, BaseRPCService, lambda name, channel: BaseClient(name, channel)))

viam/components/base/base.py

@@ -0,0 +1,260 @@
+import abc
+from dataclasses import dataclass
+from typing import Any, Dict, Final, Optional
+
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from ..component_base import ComponentBase
+from . import Vector3
+
+
+class Base(ComponentBase):
+    """
+    Base represents a physical base of a robot.
+
+    This acts as an abstract base class for any drivers representing specific
+    base implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.base import Base
+
+    For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "base"
+    )
+
+    @dataclass
+    class Properties:
+        width_meters: float
+        turning_radius_meters: float
+        wheel_circumference_meters: float
+
+    @abc.abstractmethod
+    async def move_straight(
+        self,
+        distance: int,
+        velocity: float,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Move the base in a straight line the given ``distance``, expressed in millimeters,
+        at the given ``velocity``, expressed in millimeters per second.
+        When ``distance`` or ``velocity`` is 0, the base will stop.
+        This method blocks until completed or cancelled.
+
+        ::
+
+            my_base = Base.from_robot(robot=machine, name="my_base")
+
+            # Move the base 40 mm at a velocity of 90 mm/s, forward.
+            await my_base.move_straight(distance=40, velocity=90)
+
+            # Move the base 40 mm at a velocity of -90 mm/s, backward.
+            await my_base.move_straight(distance=40, velocity=-90)
+
+        Args:
+            distance (int): The distance (in millimeters) to move.
+                Negative implies backwards.
+            velocity (float): The velocity (in millimeters per second) to move.
+                Negative implies backwards.
+
+        For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/#movestraight>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def spin(
+        self,
+        angle: float,
+        velocity: float,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Spin the base in place ``angle`` degrees, at the given angular ``velocity``,
+        expressed in degrees per second.
+        When ``velocity`` is 0, the base will stop.
+        This method blocks until completed or cancelled.
+
+        ::
+
+            my_base = Base.from_robot(robot=machine, name="my_base")
+
+            # Spin the base 10 degrees at an angular velocity of 15 deg/sec.
+            await my_base.spin(angle=10, velocity=15)
+
+        Args:
+            angle (float): The angle (in degrees) to spin.
+            velocity (float): The angular velocity (in degrees per second)
+                to spin.
+                Given a positive angle and a positive velocity, the base will turn to the left.
+
+        For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/#spin>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def set_power(
+        self,
+        linear: Vector3,
+        angular: Vector3,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """Set the linear and angular velocity of the Base
+        When ``linear`` is 0, the base will spin.
+        When ``angular`` is 0, the base will move in a straight line.
+        When both ``linear`` and ``angular`` are 0, the base will stop.
+        When ``linear`` and ``angular`` are both nonzero, the base will move in an arc,
+        with a tighter radius if angular power is greater than linear power.
+
+        ::
+
+            my_base = Base.from_robot(robot=machine, name="my_base")
+
+            # Make your wheeled base move forward. Set linear power to 75%.
+            print("move forward")
+            await my_base.set_power(
+                linear=Vector3(x=0, y=.75, z=0),
+                angular=Vector3(x=0, y=0, z=0))
+
+            # Make your wheeled base move backward. Set linear power to -100%.
+            print("move backward")
+            await my_base.set_power(
+                linear=Vector3(x=0, y=-1.0, z=0),
+                angular=Vector3(x=0, y=0, z=0))
+
+            # Make your wheeled base spin left. Set angular power to 100%.
+            print("spin left")
+            await my_base.set_power(
+                linear=Vector3(x=0, y=0, z=0),
+                angular=Vector3(x=0, y=0, z=1))
+
+            # Make your wheeled base spin right. Set angular power to -75%.
+            print("spin right")
+            await my_base.set_power(
+                linear=Vector3(x=0, y=0, z=0),
+                angular=Vector3(x=0, y=0, z=-.75))
+
+        Args:
+            linear (Vector3): The linear component. Only the Y component is used
+                for wheeled base. Positive implies forwards.
+            angular (Vector3): The angular component. Only the Z component is used
+                for wheeled base. Positive turns left; negative turns right.
+
+        For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/#setpower>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def set_velocity(
+        self,
+        linear: Vector3,
+        angular: Vector3,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Set the linear and angular velocities of the base.
+
+        ::
+
+            my_base = Base.from_robot(robot=machine, name="my_base")
+
+            # Set the linear velocity to 50 mm/sec and the angular velocity to
+            # 15 degree/sec.
+            await my_base.set_velocity(
+                linear=Vector3(x=0, y=50, z=0), angular=Vector3(x=0, y=0, z=15))
+
+        Args:
+            linear (Vector3): Velocity in mm/sec
+            angular (Vector3): Velocity in deg/sec
+
+        For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/#setvelocity>`_.
+        """
+
+    @abc.abstractmethod
+    async def stop(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        """
+        Stop the base.
+
+        ::
+
+            my_base = Base.from_robot(robot=machine, name="my_base")
+
+            # Move the base forward 10 mm at a velocity of 50 mm/s.
+            await my_base.move_straight(distance=10, velocity=50)
+
+            # Stop the base.
+            await my_base.stop()
+
+        For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/#stop>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def is_moving(self) -> bool:
+        """
+        Get if the base is currently moving.
+
+        ::
+
+            my_base = Base.from_robot(robot=machine, name="my_base")
+
+            # Check whether the base is currently moving.
+            moving = await my_base.is_moving()
+            print('Moving: ', moving)
+
+        Returns:
+            bool: Whether the base is moving.
+
+        For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/#ismoving>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> Properties:
+        """
+        Get the base width and turning radius
+
+        ::
+
+            my_base = Base.from_robot(robot=machine, name="my_base")
+
+            # Get the width and turning radius of the base
+            properties = await my_base.get_properties()
+
+            # Get the width
+            print(f"Width of base: {properties.width_meters}")
+
+            # Get the turning radius
+            print(f"Turning radius of base: {properties.turning_radius_meters}")
+
+            # Get the wheel circumference
+            print(f"Wheel circumference of base: {properties.wheel_circumference_meters}")
+
+        Returns:
+            Properties: The properties of the base
+
+        For more information, see `Base component <https://docs.viam.com/dev/reference/apis/components/base/#getproperties>`_.
+        """
+        ...

viam/components/base/client.py

@@ -0,0 +1,153 @@
+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.base import (
+    BaseServiceStub,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    MoveStraightRequest,
+    SetPowerRequest,
+    SetVelocityRequest,
+    SpinRequest,
+    StopRequest,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from . import Base, Vector3
+
+
+class BaseClient(Base, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the Base component.
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = BaseServiceStub(channel)
+        super().__init__(name)
+
+    async def move_straight(
+        self,
+        distance: int,
+        velocity: float,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = MoveStraightRequest(
+            name=self.name,
+            distance_mm=distance,
+            mm_per_sec=velocity,
+            extra=dict_to_struct(extra),
+        )
+        await self.client.MoveStraight(request, timeout=timeout, metadata=md)
+
+    async def spin(
+        self,
+        angle: float,
+        velocity: float,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = SpinRequest(
+            name=self.name,
+            angle_deg=angle,
+            degs_per_sec=velocity,
+            extra=dict_to_struct(extra),
+        )
+        await self.client.Spin(request, timeout=timeout, metadata=md)
+
+    async def set_power(
+        self,
+        linear: Vector3,
+        angular: Vector3,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = SetPowerRequest(
+            name=self.name,
+            linear=linear,
+            angular=angular,
+            extra=dict_to_struct(extra),
+        )
+        await self.client.SetPower(request, timeout=timeout, metadata=md)
+
+    async def set_velocity(
+        self,
+        linear: Vector3,
+        angular: Vector3,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = SetVelocityRequest(name=self.name, linear=linear, angular=angular, extra=dict_to_struct(extra))
+        await self.client.SetVelocity(request, timeout=timeout, metadata=md)
+
+    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 get_properties(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Base.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 Base.Properties(
+            width_meters=response.width_meters,
+            turning_radius_meters=response.turning_radius_meters,
+            wheel_circumference_meters=response.wheel_circumference_meters,
+        )
+
+    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/base/service.py

@@ -0,0 +1,138 @@
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
+from viam.proto.component.base import (
+    BaseServiceBase,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    IsMovingRequest,
+    IsMovingResponse,
+    MoveStraightRequest,
+    MoveStraightResponse,
+    SetPowerRequest,
+    SetPowerResponse,
+    SetVelocityRequest,
+    SetVelocityResponse,
+    SpinRequest,
+    SpinResponse,
+    StopRequest,
+    StopResponse,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .base import Base
+
+
+class BaseRPCService(BaseServiceBase, ResourceRPCServiceBase[Base]):
+    """
+    gRPC service for a robotic Base
+    """
+
+    RESOURCE_TYPE = Base
+
+    async def MoveStraight(self, stream: Stream[MoveStraightRequest, MoveStraightResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        base = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await base.move_straight(
+            distance=request.distance_mm,
+            velocity=request.mm_per_sec,
+            extra=struct_to_dict(request.extra),
+            timeout=timeout,
+            metadata=stream.metadata,
+        )
+        response = MoveStraightResponse()
+        await stream.send_message(response)
+
+    async def Spin(self, stream: Stream[SpinRequest, SpinResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        base = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await base.spin(
+            angle=request.angle_deg,
+            velocity=request.degs_per_sec,
+            extra=struct_to_dict(request.extra),
+            timeout=timeout,
+            metadata=stream.metadata,
+        )
+        response = SpinResponse()
+        await stream.send_message(response)
+
+    async def SetPower(self, stream: Stream[SetPowerRequest, SetPowerResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        base = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await base.set_power(
+            request.linear, request.angular, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
+        )
+        response = SetPowerResponse()
+        await stream.send_message(response)
+
+    async def SetVelocity(self, stream: Stream[SetVelocityRequest, SetVelocityResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        base = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await base.set_velocity(
+            request.linear, request.angular, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
+        )
+        await stream.send_message(SetVelocityResponse())
+
+    async def Stop(self, stream: Stream[StopRequest, StopResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        base = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await base.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = StopResponse()
+        await stream.send_message(response)
+
+    async def IsMoving(self, stream: Stream[IsMovingRequest, IsMovingResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        base = self.get_resource(name)
+        is_moving = await base.is_moving()
+        response = IsMovingResponse(is_moving=is_moving)
+        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
+        base = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await base.get_properties(timeout=timeout, metadata=stream.metadata)
+        response = GetPropertiesResponse(
+            width_meters=properties.width_meters,
+            turning_radius_meters=properties.turning_radius_meters,
+            wheel_circumference_meters=properties.wheel_circumference_meters,
+        )
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        base = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await base.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
+        base = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await base.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/board/__init__.py

@@ -0,0 +1,9 @@
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .board import Board, Tick, TickStream
+from .client import BoardClient
+from .service import BoardRPCService
+
+__all__ = ["Board", "Tick", "TickStream"]
+
+Registry.register_api(ResourceRegistration(Board, BoardRPCService, lambda name, channel: BoardClient(name, channel)))