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

viam/components/generic/__init__.py

@@ -9,7 +9,7 @@ __all__ = [
     "Generic",
 ]
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         Generic,
         GenericRPCService,

viam/components/generic/client.py

@@ -1,12 +1,12 @@
-from typing import Any, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional
 
 from grpclib import GRPCError, Status
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
 from viam.proto.component.generic import GenericServiceStub
-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.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
 from .generic import Generic
 
@@ -17,13 +17,21 @@ class GenericClient(Generic, ReconfigurableResourceRPCClientBase):
     """
 
     def __init__(self, name: str, channel: Channel):
+        self.channel = channel
         self.client = GenericServiceStub(channel)
         super().__init__(name)
 
-    async def do_command(self, command: Mapping[str, Any], *, timeout: Optional[float] = None) -> Mapping[str, Any]:
+    async def do_command(
+        self,
+        command: Mapping[str, Any],
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Mapping[str, Any]:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = DoCommandRequest(name=self.name, command=dict_to_struct(command))
         try:
-            response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout)
+            response: DoCommandResponse = await self.client.DoCommand(request, timeout=timeout, metadata=md)
         except GRPCError as e:
             if e.status == Status.UNIMPLEMENTED:
                 raise NotImplementedError()
@@ -31,9 +39,13 @@ class GenericClient(Generic, ReconfigurableResourceRPCClientBase):
 
         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)
+
 
 async def do_command(
-    channel: Channel, name: str, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None
+    channel: Channel, name: str, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs
 ) -> Mapping[str, ValueTypes]:
     """Convenience method to allow component clients to execute ``do_command`` functions
 
@@ -45,5 +57,6 @@ async def do_command(
     Returns:
         Dict[str, Any]: The result of the executed command
     """
+    md = kwargs.get("metadata", ResourceRPCClientBase.Metadata()).proto
     client = GenericClient(name, channel)
-    return await client.do_command(command, timeout=timeout)
+    return await client.do_command(command, timeout=timeout, metadata=md)

viam/components/generic/generic.py

@@ -1,6 +1,6 @@
 from typing import Final
 
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
 
 from ..component_base import ComponentBase
 
@@ -15,6 +15,10 @@ class Generic(ComponentBase):
     To create a Generic component (an arbitrary component that can process commands), this ``Generic`` component should be subclassed
     and the ``do_command`` function implemented.
 
+    ::
+
+        from viam.components.generic import Generic
+
     Example::
 
         class ComplexComponent(Generic):
@@ -63,6 +67,10 @@ class Generic(ComponentBase):
         component.power  # 1
         await asyncio.sleep(10)
         component.power  # 0
+
+    For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/generic/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "generic")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "generic"
+    )

viam/components/generic/service.py

@@ -2,8 +2,7 @@ from grpclib import GRPCError, Status
 from grpclib.server import Stream
 
 from viam.components.component_base import ComponentBase
-from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
 from viam.proto.component.generic import GenericServiceBase
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
@@ -11,7 +10,7 @@ from viam.utils import dict_to_struct, struct_to_dict
 # from .generic import Generic
 
 
-class GenericRPCService(GenericServiceBase, ResourceRPCServiceBase[ComponentBase]):
+class GenericRPCService(GenericServiceBase, ResourceRPCServiceBase):
     """
     gRPC Service for a Generic component
     """
@@ -22,10 +21,7 @@ class GenericRPCService(GenericServiceBase, ResourceRPCServiceBase[ComponentBase
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            component = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        component = self.get_resource(name)
         try:
             timeout = stream.deadline.time_remaining() if stream.deadline else None
             result = await component.do_command(struct_to_dict(request.command), timeout=timeout, metadata=stream.metadata)
@@ -33,3 +29,12 @@ class GenericRPCService(GenericServiceBase, ResourceRPCServiceBase[ComponentBase
             raise GRPCError(Status.UNIMPLEMENTED, f"``DO`` command is unimplemented for component named: {name}")
         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
+        component = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await component.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/gripper/__init__.py

@@ -1,8 +1,5 @@
-from viam.components.gantry.gantry import Gantry
-from viam.proto.common import ActuatorStatus
-from viam.proto.robot import Status
+from viam.proto.common import KinematicsFileFormat
 from viam.resource.registry import Registry, ResourceRegistration
-from viam.utils import message_to_struct
 
 from .client import GripperClient
 from .gripper import Gripper
@@ -10,14 +7,7 @@ from .service import GripperRPCService
 
 __all__ = [
     "Gripper",
+    "KinematicsFileFormat",
 ]
 
-
-async def create_status(component: Gripper) -> Status:
-    s = ActuatorStatus(is_moving=await component.is_moving())
-    return Status(name=Gripper.get_resource_name(component.name), status=message_to_struct(s))
-
-
-Registry.register_subtype(
-    ResourceRegistration(Gripper, GripperRPCService, lambda name, channel: GripperClient(name, channel), create_status)
-)
+Registry.register_api(ResourceRegistration(Gripper, GripperRPCService, lambda name, channel: GripperClient(name, channel)))

viam/components/gripper/client.py

@@ -1,20 +1,23 @@
-from typing import Any, Dict, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetKinematicsRequest, GetKinematicsResponse
 from viam.proto.component.gripper import (
     GrabRequest,
     GrabResponse,
     GripperServiceStub,
+    IsHoldingSomethingRequest,
+    IsHoldingSomethingResponse,
     IsMovingRequest,
     IsMovingResponse,
     OpenRequest,
     StopRequest,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
+from . import KinematicsFileFormat
 from .gripper import Gripper
 
 
@@ -28,33 +31,78 @@ class GripperClient(Gripper, ReconfigurableResourceRPCClientBase):
         self.client = GripperServiceStub(channel)
         super().__init__(name)
 
-    async def open(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def open(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = OpenRequest(name=self.name, extra=dict_to_struct(extra))
-        await self.client.Open(request, timeout=timeout)
+        await self.client.Open(request, timeout=timeout, metadata=md)
 
-    async def grab(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> bool:
-        if extra is None:
-            extra = {}
+    async def grab(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> bool:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GrabRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GrabResponse = await self.client.Grab(request, timeout=timeout)
+        response: GrabResponse = await self.client.Grab(request, timeout=timeout, metadata=md)
         return response.success
 
-    async def stop(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    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)
+        await self.client.Stop(request, timeout=timeout, metadata=md)
 
-    async def is_moving(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> bool:
-        if extra is None:
-            extra = {}
+    async def is_holding_something(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Gripper.HoldingStatus:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = IsHoldingSomethingRequest(name=self.name, extra=dict_to_struct(extra))
+        response: IsHoldingSomethingResponse = await self.client.IsHoldingSomething(request, timeout=timeout, metadata=md)
+        return Gripper.HoldingStatus(response.is_holding_something, meta=struct_to_dict(response.meta))
+
+    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)
+        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) -> 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 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 get_kinematics(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetKinematicsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetKinematicsResponse = await self.client.GetKinematics(request, timeout=timeout, metadata=md)
+        return (response.format, response.kinematics_data)

viam/components/gripper/gripper.py

@@ -1,8 +1,11 @@
 import abc
-from typing import Any, Dict, Final, Optional
+from dataclasses import dataclass
+from typing import Any, Dict, Final, Optional, Tuple
 
 from viam.components.component_base import ComponentBase
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from . import KinematicsFileFormat
 
 
 class Gripper(ComponentBase):
@@ -12,9 +15,28 @@ class Gripper(ComponentBase):
     This acts as an abstract base class for any drivers representing specific
     gripper implementations. This cannot be used on its own. If the ``__init__()`` function is
     overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.gripper import Gripper
+
+    For more information, see `Gripper component <https://docs.viam.com/dev/reference/apis/components/gripper/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "gripper")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "gripper"
+    )
+
+    @dataclass
+    class HoldingStatus:
+        """
+        HoldingStatus represents whether the gripper is currently holding onto an object. The
+        additional ``meta`` attribute contains other optional contextual information (i.e. confidence
+        interval, pressure, etc.)
+        """
+
+        is_holding_something: bool
+        meta: Optional[Dict[str, Any]] = None
 
     @abc.abstractmethod
     async def open(
@@ -26,6 +48,15 @@ class Gripper(ComponentBase):
     ):
         """
         Open the gripper.
+
+        ::
+
+            my_gripper = Gripper.from_robot(robot=machine, name="my_gripper")
+
+            # Open the gripper.
+            await my_gripper.open()
+
+        For more information, see `Gripper component <https://docs.viam.com/dev/reference/apis/components/gripper/#open>`_.
         """
         ...
 
@@ -40,11 +71,47 @@ class Gripper(ComponentBase):
         """
         Instruct the gripper to grab.
 
+        ::
+
+            my_gripper = Gripper.from_robot(robot=machine, name="my_gripper")
+
+            # Grab with the gripper.
+            grabbed = await my_gripper.grab()
+
         Returns:
             bool: Indicates if the gripper grabbed something.
+
+        For more information, see `Gripper component <https://docs.viam.com/dev/reference/apis/components/gripper/#grab>`_.
         """
         ...
 
+    @abc.abstractmethod
+    async def is_holding_something(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> HoldingStatus:
+        """
+        Get information about whether the gripper is currently holding onto an object.
+
+        ::
+
+            my_gripper = Gripper.from_robot(robot=machine, name="my_gripper")
+
+            # Grab with the gripper.
+            holding_status = await my_gripper.is_holding_something()
+            # get the boolean result
+            is_holding_something = holding_status.is_holding_something
+
+        Returns:
+            HoldingStatus: see documentation on `HoldingStatus` for more information
+
+        For more information, see `Gripper component <https://docs.viam.com/dev/reference/apis/components/gripper/#grab>`_.
+
+        """
+
     @abc.abstractmethod
     async def stop(
         self,
@@ -55,6 +122,15 @@ class Gripper(ComponentBase):
     ):
         """
         Stop the gripper. It is assumed the gripper stops immediately.
+
+        ::
+
+            my_gripper = Gripper.from_robot(robot=machine, name="my_gripper")
+
+            # Stop the gripper.
+            await my_gripper.stop()
+
+        For more information, see `Gripper component <https://docs.viam.com/dev/reference/apis/components/gripper/#stop>`_.
         """
         ...
 
@@ -63,7 +139,51 @@ class Gripper(ComponentBase):
         """
         Get if the gripper is currently moving.
 
+        ::
+
+            my_gripper = Gripper.from_robot(robot=machine, name="my_gripper")
+
+            # Check whether the gripper is currently moving.
+            moving = await my_gripper.is_moving()
+            print('Moving:', moving)
+
         Returns:
             bool: Whether the gripper is moving.
+
+        For more information, see `Gripper component <https://docs.viam.com/dev/reference/apis/components/gripper/#is_moving>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_kinematics(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        """
+        Get the kinematics information associated with the gripper.
+
+        ::
+
+            my_gripper = Gripper.from_robot(robot=machine, name="my_gripper")
+
+            # Get the kinematics information associated with the gripper.
+            kinematics = await my_gripper.get_kinematics()
+
+            # Get the format of the kinematics file.
+            k_file = kinematics[0]
+
+            # Get the byte contents of the file.
+            k_bytes = kinematics[1]
+
+        Returns:
+            Tuple[KinematicsFileFormat.ValueType, bytes]: A tuple containing two values; the first [0] value represents the format of the
+            file, either in URDF format (``KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF``) or
+            Viam's kinematic parameter format (spatial vector algebra) (``KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA``),
+            and the second [1] value represents the byte contents of the file.
+
+        For more information, see `Gripper component <https://docs.viam.com/dev/reference/apis/components/gripper/#getkinematics>`_.
         """
         ...

viam/components/gripper/service.py

@@ -1,11 +1,19 @@
 from grpclib.server import Stream
 
-from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetKinematicsRequest,
+    GetKinematicsResponse,
+)
 from viam.proto.component.gripper import (
     GrabRequest,
     GrabResponse,
     GripperServiceBase,
+    IsHoldingSomethingRequest,
+    IsHoldingSomethingResponse,
     IsMovingRequest,
     IsMovingResponse,
     OpenRequest,
@@ -30,10 +38,7 @@ class GripperRPCService(GripperServiceBase, ResourceRPCServiceBase[Gripper]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gripper = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gripper = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await gripper.open(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = OpenResponse()
@@ -43,10 +48,7 @@ class GripperRPCService(GripperServiceBase, ResourceRPCServiceBase[Gripper]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gripper = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gripper = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         grabbed = await gripper.grab(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GrabResponse(success=grabbed)
@@ -55,10 +57,7 @@ class GripperRPCService(GripperServiceBase, ResourceRPCServiceBase[Gripper]):
     async def Stop(self, stream: Stream[StopRequest, StopResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            gripper = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gripper = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await gripper.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(StopResponse())
@@ -67,22 +66,45 @@ class GripperRPCService(GripperServiceBase, ResourceRPCServiceBase[Gripper]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gripper = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gripper = self.get_resource(name)
         is_moving = await gripper.is_moving()
         response = IsMovingResponse(is_moving=is_moving)
         await stream.send_message(response)
 
+    async def IsHoldingSomething(self, stream: Stream[IsHoldingSomethingRequest, IsHoldingSomethingResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        gripper = self.get_resource(name)
+        holding_status = await gripper.is_holding_something()
+        response = IsHoldingSomethingResponse(
+            is_holding_something=holding_status.is_holding_something, meta=dict_to_struct(holding_status.meta)
+        )
+        await stream.send_message(response)
+
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            gripper = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gripper = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await gripper.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
+        gripper = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await gripper.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)
+
+    async def GetKinematics(self, stream: Stream[GetKinematicsRequest, GetKinematicsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        gripper = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        format, kinematics_data = await gripper.get_kinematics(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetKinematicsResponse(format=format, kinematics_data=kinematics_data)
+        await stream.send_message(response)

viam/components/input/__init__.py

@@ -1,7 +1,4 @@
-from viam.proto.component.inputcontroller import Status as InputStatus
-from viam.proto.robot import Status
 from viam.resource.registry import Registry, ResourceRegistration
-from viam.utils import message_to_struct
 
 from .client import ControllerClient
 from .input import Control, ControlFunction, Controller, Event, EventType
@@ -15,14 +12,4 @@ __all__ = [
     "EventType",
 ]
 
-
-async def create_status(component: Controller) -> Status:
-    return Status(
-        name=Controller.get_resource_name(component.name),
-        status=message_to_struct(InputStatus(events=[event.proto for event in (await component.get_events()).values()])),
-    )
-
-
-Registry.register_subtype(
-    ResourceRegistration(Controller, InputControllerRPCService, lambda name, channel: ControllerClient(name, channel), create_status)
-)
+Registry.register_api(ResourceRegistration(Controller, InputControllerRPCService, lambda name, channel: ControllerClient(name, channel)))