viam-sdk 0.3.0__py3-none-linux_armv6l.whl → 0.66.0__py3-none-linux_armv6l.whl

viam/components/board/client.py

@@ -1,11 +1,11 @@
 from datetime import timedelta
-from multiprocessing import Queue
 from typing import Any, Dict, List, Mapping, Optional
 
 from google.protobuf.duration_pb2 import Duration
 from grpclib.client import Channel
+from grpclib.client import Stream as ClientStream
 
-from viam.proto.common import BoardStatus, DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
 from viam.proto.component.board import (
     BoardServiceStub,
     GetDigitalInterruptValueRequest,
@@ -18,31 +18,48 @@ from viam.proto.component.board import (
     PWMRequest,
     PWMResponse,
     ReadAnalogReaderRequest,
-    ReadAnalogReaderResponse,
     SetGPIORequest,
     SetPowerModeRequest,
     SetPWMFrequencyRequest,
     SetPWMRequest,
-    StatusRequest,
-    StatusResponse,
+    StreamTicksRequest,
+    StreamTicksResponse,
+    WriteAnalogRequest,
 )
-from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase, ResourceRPCClientBase
+from viam.streams import StreamWithIterator
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
-from .board import Board, PostProcessor
+from .board import Board, TickStream
 
 
-class AnalogReaderClient(Board.AnalogReader):
+class AnalogClient(Board.Analog):
     def __init__(self, name: str, board: "BoardClient"):
         self.board = board
         super().__init__(name)
 
-    async def read(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> int:
-        if extra is None:
-            extra = {}
+    async def read(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Board.Analog.Value:
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = ReadAnalogReaderRequest(board_name=self.board.name, analog_reader_name=self.name, extra=dict_to_struct(extra))
-        response: ReadAnalogReaderResponse = await self.board.client.ReadAnalogReader(request, timeout=timeout)
-        return response.value
+        return await self.board.client.ReadAnalogReader(request, timeout=timeout, metadata=md)
+
+    async def write(
+        self,
+        value: int,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
+        request = WriteAnalogRequest(name=self.board.name, pin=self.name, value=value, extra=dict_to_struct(extra))
+        await self.board.client.WriteAnalog(request, timeout=timeout, metadata=md)
 
 
 class DigitalInterruptClient(Board.DigitalInterrupt):
@@ -50,66 +67,95 @@ class DigitalInterruptClient(Board.DigitalInterrupt):
         self.board = board
         super().__init__(name)
 
-    async def value(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> int:
-        if extra is None:
-            extra = {}
+    async def value(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> int:
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = GetDigitalInterruptValueRequest(board_name=self.board.name, digital_interrupt_name=self.name, extra=dict_to_struct(extra))
-        response: GetDigitalInterruptValueResponse = await self.board.client.GetDigitalInterruptValue(request, timeout=timeout)
+        response: GetDigitalInterruptValueResponse = await self.board.client.GetDigitalInterruptValue(request, timeout=timeout, metadata=md)
         return response.value
 
-    async def tick(self, high: bool, nanos: int):
-        raise NotImplementedError()
-
-    async def add_callback(self, queue: Queue):
-        raise NotImplementedError()
-
-    async def add_post_processor(self, processor: PostProcessor):
-        raise NotImplementedError()
-
 
 class GPIOPinClient(Board.GPIOPin):
     def __init__(self, name: str, board: "BoardClient"):
         self.board = board
         super().__init__(name)
 
-    async def get(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> bool:
-        if extra is None:
-            extra = {}
+    async def get(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> bool:
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = GetGPIORequest(name=self.board.name, pin=self.name, extra=dict_to_struct(extra))
-        response: GetGPIOResponse = await self.board.client.GetGPIO(request, timeout=timeout)
+        response: GetGPIOResponse = await self.board.client.GetGPIO(request, timeout=timeout, metadata=md)
         return response.high
 
-    async def set(self, high: bool, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def set(
+        self,
+        high: bool,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = SetGPIORequest(name=self.board.name, pin=self.name, high=high, extra=dict_to_struct(extra))
-        await self.board.client.SetGPIO(request, timeout=timeout)
+        await self.board.client.SetGPIO(request, timeout=timeout, metadata=md)
 
-    async def get_pwm(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> float:
-        if extra is None:
-            extra = {}
+    async def get_pwm(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> float:
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = PWMRequest(name=self.board.name, pin=self.name, extra=dict_to_struct(extra))
-        response: PWMResponse = await self.board.client.PWM(request, timeout=timeout)
+        response: PWMResponse = await self.board.client.PWM(request, timeout=timeout, metadata=md)
         return response.duty_cycle_pct
 
-    async def set_pwm(self, duty_cycle: float, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def set_pwm(
+        self,
+        duty_cycle: float,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = SetPWMRequest(name=self.board.name, pin=self.name, duty_cycle_pct=duty_cycle, extra=dict_to_struct(extra))
-        await self.board.client.SetPWM(request, timeout=timeout)
+        await self.board.client.SetPWM(request, timeout=timeout, metadata=md)
 
-    async def get_pwm_frequency(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> int:
-        if extra is None:
-            extra = {}
+    async def get_pwm_frequency(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> int:
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = PWMFrequencyRequest(name=self.board.name, pin=self.name, extra=dict_to_struct(extra))
-        response: PWMFrequencyResponse = await self.board.client.PWMFrequency(request, timeout=timeout)
+        response: PWMFrequencyResponse = await self.board.client.PWMFrequency(request, timeout=timeout, metadata=md)
         return response.frequency_hz
 
-    async def set_pwm_frequency(self, frequency: int, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def set_pwm_frequency(
+        self,
+        frequency: int,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
         request = SetPWMFrequencyRequest(name=self.board.name, pin=self.name, frequency_hz=frequency, extra=dict_to_struct(extra))
-        await self.board.client.SetPWMFrequency(request, timeout=timeout)
+        await self.board.client.SetPWMFrequency(request, timeout=timeout, metadata=md)
 
 
 class BoardClient(Board, ReconfigurableResourceRPCClientBase):
@@ -117,49 +163,37 @@ class BoardClient(Board, ReconfigurableResourceRPCClientBase):
     gRPC client for the Board component.
     """
 
+    _analog_names: List[str]
+    _digital_interrupt_names: List[str]
+
     def __init__(self, name: str, channel: Channel):
         self.channel = channel
         self.client = BoardServiceStub(channel)
-        self._analog_reader_names: Optional[List[str]] = None
-        self._digital_interrupt_names: Optional[List[str]] = None
+        self._analog_names = []
+        self._digital_interrupt_names = []
         super().__init__(name)
 
-    async def analog_reader_by_name(self, name: str) -> Board.AnalogReader:
-        return AnalogReaderClient(name, self)
+    async def analog_by_name(self, name: str) -> Board.Analog:
+        self._analog_names.append(name)
+        return AnalogClient(name, self)
 
     async def digital_interrupt_by_name(self, name: str) -> Board.DigitalInterrupt:
+        self._digital_interrupt_names.append(name)
         return DigitalInterruptClient(name, self)
 
     async def gpio_pin_by_name(self, name: str) -> Board.GPIOPin:
         return GPIOPinClient(name, self)
 
-    async def analog_reader_names(self) -> List[str]:
-        if self._analog_reader_names is None:
-            status = await self.status()
-            names = [name for name in status.analogs.keys()]
-            self._analog_reader_names = names
-        return self._analog_reader_names
-
-    async def digital_interrupt_names(self) -> List[str]:
-        if self._digital_interrupt_names is None:
-            status = await self.status()
-            names = [name for name in status.digital_interrupts.keys()]
-            self._digital_interrupt_names = names
-        return self._digital_interrupt_names
-
-    async def status(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> BoardStatus:
-        if extra is None:
-            extra = {}
-        request = StatusRequest(name=self.name, extra=dict_to_struct(extra))
-        response: StatusResponse = await self.client.Status(request, timeout=timeout)
-        return response.status
-
-    async def model_attributes(self) -> Board.Attributes:
-        return Board.Attributes(remote=True)
-
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None) -> Mapping[str, ValueTypes]:
+    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)
+        response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout, metadata=md)
         return struct_to_dict(response.result)
 
     async def set_power_mode(
@@ -167,10 +201,42 @@ class BoardClient(Board, ReconfigurableResourceRPCClientBase):
         mode: PowerMode.ValueType,
         duration: Optional[timedelta] = None,
         *,
+        extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ):
+        md = kwargs.get("metadata", self.Metadata()).proto
         duration_pb: Optional[Duration] = None
         if duration is not None:
             duration_pb = [(d, d.FromTimedelta(duration)) for d in [Duration()]][0][0]
-        request = SetPowerModeRequest(name=self.name, power_mode=mode, duration=duration_pb)
-        await self.client.SetPowerMode(request, timeout=timeout)
+        request = SetPowerModeRequest(name=self.name, power_mode=mode, duration=duration_pb, extra=dict_to_struct(extra))
+        await self.client.SetPowerMode(request, timeout=timeout, metadata=md)
+
+    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)
+
+    async def stream_ticks(
+        self,
+        interrupts: List[Board.DigitalInterrupt],
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> TickStream:
+        names = []
+        for di in interrupts:
+            names.append(di.name)
+        request = StreamTicksRequest(name=self.name, pin_names=names, extra=dict_to_struct(extra))
+
+        async def read():
+            md = kwargs.get("metadata", self.Metadata()).proto
+            tick_stream: ClientStream[StreamTicksRequest, StreamTicksResponse]
+            async with self.client.StreamTicks.open(metadata=md) as tick_stream:
+                try:
+                    await tick_stream.send_message(request, end=True)
+                    async for tick in tick_stream:
+                        yield tick
+                except Exception as e:
+                    raise (e)
+
+        return StreamWithIterator(read())

viam/components/board/service.py

@@ -1,7 +1,9 @@
 from grpclib.server import Stream
+from h2.exceptions import StreamClosedError
 
 from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.logging import getLogger
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
 from viam.proto.component.board import (
     BoardServiceBase,
     GetDigitalInterruptValueRequest,
@@ -22,14 +24,18 @@ from viam.proto.component.board import (
     SetPWMFrequencyResponse,
     SetPWMRequest,
     SetPWMResponse,
-    StatusRequest,
-    StatusResponse,
+    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]):
     """
@@ -38,25 +44,12 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
 
     RESOURCE_TYPE = Board
 
-    async def Status(self, stream: Stream[StatusRequest, StatusResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        name = request.name
-        try:
-            board = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
-        timeout = stream.deadline.time_remaining() if stream.deadline else None
-        status = await board.status(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
-        response = StatusResponse(status=status)
-        await stream.send_message(response)
-
     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:
-            board = self.get_resource(name)
             pin = await board.gpio_pin_by_name(request.pin)
         except ResourceNotFoundError as e:
             raise e.grpc_error
@@ -69,8 +62,8 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
+        board = self.get_resource(name)
         try:
-            board = self.get_resource(name)
             pin = await board.gpio_pin_by_name(request.pin)
         except ResourceNotFoundError as e:
             raise e.grpc_error
@@ -83,8 +76,8 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
+        board = self.get_resource(name)
         try:
-            board = self.get_resource(name)
             pin = await board.gpio_pin_by_name(request.pin)
         except ResourceNotFoundError as e:
             raise e.grpc_error
@@ -97,8 +90,8 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
+        board = self.get_resource(name)
         try:
-            board = self.get_resource(name)
             pin = await board.gpio_pin_by_name(request.pin)
         except ResourceNotFoundError as e:
             raise e.grpc_error
@@ -111,8 +104,8 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
+        board = self.get_resource(name)
         try:
-            board = self.get_resource(name)
             pin = await board.gpio_pin_by_name(request.pin)
         except ResourceNotFoundError as e:
             raise e.grpc_error
@@ -125,8 +118,8 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
+        board = self.get_resource(name)
         try:
-            board = self.get_resource(name)
             pin = await board.gpio_pin_by_name(request.pin)
         except ResourceNotFoundError as e:
             raise e.grpc_error
@@ -139,22 +132,21 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         request = await stream.recv_message()
         assert request is not None
         name = request.board_name
+        board = self.get_resource(name)
         try:
-            board = self.get_resource(name)
-            analog_reader = await board.analog_reader_by_name(request.analog_reader_name)
+            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
-        value = await analog_reader.read(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
-        response = ReadAnalogReaderResponse(value=value)
+        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:
-            board = self.get_resource(name)
             interrupt = await board.digital_interrupt_by_name(request.digital_interrupt_name)
         except ResourceNotFoundError as e:
             raise e.grpc_error
@@ -167,28 +159,66 @@ class BoardRPCService(BoardServiceBase, ResourceRPCServiceBase[Board]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            board = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        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(),
+            extra=struct_to_dict(request.extra),
             timeout=timeout,
             metadata=stream.metadata,
         )
         response = SetPowerModeResponse()
         await stream.send_message(response)
 
-    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+    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:
-            board = self.get_resource(request.name)
+            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)