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

viam/robot/service.py

@@ -1,78 +1,37 @@
-import asyncio
-from typing import Any, Dict, Iterable, List
+from typing import Any, Dict, List, Set
 
 from grpclib.server import Stream
 
 from viam import logging
-from viam.errors import MethodNotImplementedError, ViamGRPCError
+from viam.components.movement_sensor import MovementSensor
+from viam.components.sensor import Sensor
+from viam.errors import ViamGRPCError
 from viam.proto.common import ResourceName
 from viam.proto.robot import (
-    BlockForOperationRequest,
-    BlockForOperationResponse,
-    CancelOperationRequest,
-    CancelOperationResponse,
-    DiscoverComponentsRequest,
-    DiscoverComponentsResponse,
-    FrameSystemConfigRequest,
-    FrameSystemConfigResponse,
-    GetOperationsRequest,
-    GetOperationsResponse,
-    GetSessionsRequest,
-    GetSessionsResponse,
-    GetStatusRequest,
-    GetStatusResponse,
     ResourceNamesRequest,
     ResourceNamesResponse,
-    ResourceRPCSubtypesRequest,
-    ResourceRPCSubtypesResponse,
-    RobotServiceBase,
-    SendSessionHeartbeatRequest,
-    SendSessionHeartbeatResponse,
-    StartSessionRequest,
-    StartSessionResponse,
-    Status,
     StopAllRequest,
     StopAllResponse,
-    StreamStatusRequest,
-    StreamStatusResponse,
-    TransformPCDRequest,
-    TransformPCDResponse,
-    TransformPoseRequest,
-    TransformPoseResponse,
+    UnimplementedRobotServiceBase,
 )
-from viam.resource.registry import Registry
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import resource_names_for_resource, struct_to_dict
 
 LOGGER = logging.getLogger(__name__)
 
 
-class RobotService(RobotServiceBase, ResourceRPCServiceBase):
+class RobotService(UnimplementedRobotServiceBase, ResourceRPCServiceBase):
     def _generate_metadata(self) -> List[ResourceName]:
-        md: List[ResourceName] = []
+        md: Set[ResourceName] = set()
 
-        for component in self.manager.resources.values():
-            md.extend(resource_names_for_resource(component))
-
-        return md
-
-    async def _generate_status(self, resource_names: Iterable[ResourceName]) -> List[Status]:
-        statuses: List[Status] = []
+        for resource in self.manager.resources.values():
+            # If the resource is a MovementSensor, DO NOT include Sensor as well (it will get added via MovementSensor)
+            if resource.API == Sensor.API and MovementSensor.get_resource_name(resource.name) in self.manager.resources:
+                continue
 
-        for component in self.manager.resources.values():
-            for registration in Registry.REGISTERED_SUBTYPES().values():
-                if isinstance(component, registration.resource_type):
-                    if resource_names and component.get_resource_name(component.name) not in resource_names:
-                        continue
-                    try:
-                        status = await registration.create_status(component)
-                        statuses.append(status)
-                    except ViamGRPCError as e:
-                        raise e.grpc_error
+            md.update(resource_names_for_resource(resource))
 
-        if resource_names:
-            statuses = [s for s in statuses if s.name in resource_names]
-        return statuses
+        return list(md)
 
     async def ResourceNames(self, stream: Stream[ResourceNamesRequest, ResourceNamesResponse]) -> None:
         request = await stream.recv_message()
@@ -81,47 +40,6 @@ class RobotService(RobotServiceBase, ResourceRPCServiceBase):
         response = ResourceNamesResponse(resources=metadata)
         await stream.send_message(response)
 
-    async def GetStatus(self, stream: Stream[GetStatusRequest, GetStatusResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        status = await self._generate_status(request.resource_names)
-        response = GetStatusResponse(status=status)
-        await stream.send_message(response)
-
-    async def StreamStatus(self, stream: Stream[StreamStatusRequest, StreamStatusResponse]) -> None:
-        request = await stream.recv_message()
-        assert request is not None
-        interval = 1
-        every = request.every.ToSeconds()
-        if every > 0:
-            interval = every
-        while True:
-            status = await self._generate_status(request.resource_names)
-            response = StreamStatusResponse(status=status)
-            await stream.send_message(response)
-            await asyncio.sleep(interval)
-
-    async def GetOperations(self, stream: Stream[GetOperationsRequest, GetOperationsResponse]) -> None:
-        raise MethodNotImplementedError("GetOperations").grpc_error
-
-    async def ResourceRPCSubtypes(self, stream: Stream[ResourceRPCSubtypesRequest, ResourceRPCSubtypesResponse]) -> None:
-        raise MethodNotImplementedError("ResourceRPCSubtypes").grpc_error
-
-    async def CancelOperation(self, stream: Stream[CancelOperationRequest, CancelOperationResponse]) -> None:
-        raise MethodNotImplementedError("CancelOperation").grpc_error
-
-    async def BlockForOperation(self, stream: Stream[BlockForOperationRequest, BlockForOperationResponse]) -> None:
-        raise MethodNotImplementedError("BlockForOperation").grpc_error
-
-    async def FrameSystemConfig(self, stream: Stream[FrameSystemConfigRequest, FrameSystemConfigResponse]) -> None:
-        raise MethodNotImplementedError("FrameSystemConfig").grpc_error
-
-    async def TransformPose(self, stream: Stream[TransformPoseRequest, TransformPoseResponse]) -> None:
-        raise MethodNotImplementedError("TransformPose").grpc_error
-
-    async def DiscoverComponents(self, stream: Stream[DiscoverComponentsRequest, DiscoverComponentsResponse]) -> None:
-        raise MethodNotImplementedError("DiscoverComponents").grpc_error
-
     async def StopAll(self, stream: Stream[StopAllRequest, StopAllResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
@@ -149,15 +67,3 @@ class RobotService(RobotServiceBase, ResourceRPCServiceBase):
         if errors:
             raise ViamGRPCError(f'Failed to stop components named {", ".join(errors)}')
         await stream.send_message(StopAllResponse())
-
-    async def GetSessions(self, stream: Stream[GetSessionsRequest, GetSessionsResponse]) -> None:
-        raise MethodNotImplementedError("GetSessions").grpc_error
-
-    async def StartSession(self, stream: Stream[StartSessionRequest, StartSessionResponse]) -> None:
-        raise MethodNotImplementedError("StartSession").grpc_error
-
-    async def SendSessionHeartbeat(self, stream: Stream[SendSessionHeartbeatRequest, SendSessionHeartbeatResponse]) -> None:
-        raise MethodNotImplementedError("SendSessionHeartbeat").grpc_error
-
-    async def TransformPCD(self, stream: Stream[TransformPCDRequest, TransformPCDResponse]) -> None:
-        raise MethodNotImplementedError("TransformPCD").grpc_error

viam/rpc/dial.py

@@ -4,33 +4,34 @@ import re
 import socket
 import ssl
 import sys
+import uuid
 import warnings
 from dataclasses import dataclass
 from typing import Callable, Literal, Optional, Tuple, Type, Union
 
 from grpclib.client import Channel, Stream
 from grpclib.const import Cardinality
+from grpclib.events import SendRequest, listen
 from grpclib.metadata import Deadline, _MetadataLike
 from grpclib.protocol import H2Protocol
 from grpclib.stream import _RecvType, _SendType
+from typing_extensions import Self
 
 from viam import logging
 from viam.errors import InsecureConnectionError, ViamError
 from viam.proto.rpc.auth import AuthenticateRequest, AuthServiceStub
 from viam.proto.rpc.auth import Credentials as PBCredentials
 from viam.utils import to_thread
+from viam.version_metadata import API_VERSION, SDK_VERSION
 
 LOGGER = logging.getLogger(__name__)
 
 
 @dataclass
 class Credentials:
-    """Credentials to connect to the robot.
+    """Credentials to connect to the machine and app.viam.com."""
 
-    Currently only supports robot location secret.
-    """
-
-    type: Literal["robot-location-secret"]
+    type: Union[Literal["robot-secret"], Literal["api-key"]]
     """The type of credential
     """
 
@@ -66,14 +67,34 @@ class DialOptions:
     if detected, even with credentials present. This is generally
     unsafe to use, but can be requested."""
 
+    max_reconnect_attempts: int = 3
+    """Max number of times the client attempts to reconnect when connection is lost"""
+
+    initial_connection_attempts: int = 3
+    """Max number of times the client will attempt to establish an initial connection
+    If set to a non-positive integer, then there will be no limit to initial connection attempts"""
+
+    initial_connection_attempt_timeout: float
+    """Number of seconds before dial connection times out on initial connection attempts
+    Defaults to whatever value is set in the `timeout` field"""
+
+    timeout: float = 20
+    """Number of seconds before the dial connection times out
+    Set to 20sec to match _defaultOfferDeadline in goutils/rpc/wrtc_call_queue.go"""
+
     def __init__(
         self,
+        *,
         disable_webrtc: bool = False,
         auth_entity: Optional[str] = None,
         credentials: Optional[Credentials] = None,
         insecure: bool = False,
         allow_insecure_downgrade: bool = False,
         allow_insecure_with_creds_downgrade: bool = False,
+        max_reconnect_attempts: int = 3,
+        timeout: float = 20,
+        initial_connection_attempts: int = 3,
+        initial_connection_attempt_timeout: Optional[float] = None,
     ) -> None:
         self.disable_webrtc = disable_webrtc
         self.auth_entity = auth_entity
@@ -81,6 +102,32 @@ class DialOptions:
         self.insecure = insecure
         self.allow_insecure_downgrade = allow_insecure_downgrade
         self.allow_insecure_with_creds_downgrade = allow_insecure_with_creds_downgrade
+        self.max_reconnect_attempts = max_reconnect_attempts
+        self.timeout = timeout
+        self.initial_connection_attempts = initial_connection_attempts
+        self.initial_connection_attempt_timeout = initial_connection_attempt_timeout if initial_connection_attempt_timeout else timeout
+
+    @classmethod
+    def with_api_key(cls, api_key: str, api_key_id: str) -> Self:
+        """Create DialOptions with an API key for credentials and default values for other arguments.
+
+        Args:
+            api_key (str): your API key
+            api_key_id (str): your API key ID. Must be a valid UUID
+
+        Raises:
+            ValueError: Raised if the api_key_id is not a valid UUID
+
+        Returns:
+            Self: the DialOptions
+        """
+        try:
+            uuid.UUID(api_key_id)
+        except ValueError:
+            raise ValueError(f"{api_key_id} is not a valid UUID")
+
+        credentials = Credentials(type="api-key", payload=api_key)
+        return cls(credentials=credentials, auth_entity=api_key_id)
 
 
 def _host_port_from_url(url) -> Tuple[Optional[str], Optional[int]]:
@@ -160,6 +207,12 @@ class ViamChannel:
         if not self._closed:
             try:
                 self.channel.close()
+            except RuntimeError as e:
+                # ignore event loop is closed errors - robot is getting shutdown
+                if len(e.args) > 0 and e.args[0] == "Event loop is closed":
+                    LOGGER.debug("ViamChannel might not have shut down cleanly - Event loop was closed")
+                    return
+                raise
             finally:
                 self.release()
                 self._closed = True
@@ -179,13 +232,22 @@ class _Runtime:
     _ptr: ctypes.c_void_p
 
     def __init__(self) -> None:
+        suffix = "dylib" if sys.platform == "darwin" else "so" if "linux" in sys.platform else "dll"
         LOGGER.debug("Creating new viam-rust-utils runtime")
-        libname = pathlib.Path(__file__).parent.absolute() / f"libviam_rust_utils.{'dylib' if sys.platform == 'darwin' else 'so'}"
+        libname = pathlib.Path(__file__).parent.absolute() / f"libviam_rust_utils.{suffix}"
         self._lib = ctypes.CDLL(libname.__str__())
         self._lib.init_rust_runtime.argtypes = ()
         self._lib.init_rust_runtime.restype = ctypes.c_void_p
 
-        self._lib.dial.argtypes = (ctypes.c_char_p, ctypes.c_char_p, ctypes.c_bool, ctypes.c_void_p)
+        self._lib.dial.argtypes = (
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_bool,
+            ctypes.c_float,
+            ctypes.c_void_p,
+        )
         self._lib.dial.restype = ctypes.c_void_p
 
         self._lib.free_rust_runtime.argtypes = (ctypes.c_void_p,)
@@ -197,20 +259,27 @@ class _Runtime:
         self._ptr = self._lib.init_rust_runtime()
 
     async def dial(self, address: str, options: DialOptions) -> Tuple[Optional[str], ctypes.c_void_p]:
-        creds = options.credentials.payload if options.credentials else ""
-        insecure = options.insecure or options.allow_insecure_with_creds_downgrade or (not creds and options.allow_insecure_downgrade)
+        type = options.credentials.type if options.credentials else ""
+        payload = options.credentials.payload if options.credentials else ""
+        insecure = (
+            options.insecure
+            or options.allow_insecure_with_creds_downgrade
+            or (not type and not payload and options.allow_insecure_downgrade)
+        )
 
         LOGGER.debug(f"Dialing {address} using viam-rust-utils library")
         path_ptr = await to_thread(
             self._lib.dial,
             address.encode("utf-8"),
-            creds.encode("utf-8") if creds else None,
+            options.auth_entity.encode("utf-8") if options.auth_entity else None,
+            type.encode("utf-8") if type else None,
+            payload.encode("utf-8") if payload else None,
             insecure,
+            ctypes.c_float(options.timeout),
             self._ptr,
         )
         path = ctypes.cast(path_ptr, ctypes.c_char_p).value
         path = path.decode("utf-8") if path else ""
-
         return (path, path_ptr)
 
     def release(self):
@@ -223,15 +292,50 @@ class _Runtime:
 
 
 async def dial(address: str, options: Optional[DialOptions] = None) -> ViamChannel:
+    options = options if options else DialOptions()
+    timeout = options.timeout
+    options.timeout = options.initial_connection_attempt_timeout
+    if options.initial_connection_attempts == 0:
+        options.initial_connection_attempts = -1
+    attempt_countdown = options.initial_connection_attempts
+    exception: Exception
+    while attempt_countdown != 0:
+        try:
+            chan = await _dial_inner(address, options)
+            options.timeout = timeout
+            return chan
+        except Exception as e:
+            exception = e
+            attempt_countdown -= 1
+    # the only way we could get here is if we failed at least once which means we've set the
+    # exception, so typechecker concerns about a possibly unbounded variable are unfounded
+    raise exception  # type: ignore
+
+
+def _create_chan(path: str) -> Channel:
+    if sys.platform == "win32" or sys.platform == "cygwin":
+        # we have to use a TCP connection, so we want a host and port for our channel.
+        host, port = _host_port_from_url(path)
+        return Channel(host=host, port=port, ssl=None)
+    # we're not on windows and so can use a UDS
+    return Channel(path=path, ssl=None)
+
+
+async def _dial_inner(address: str, options: Optional[DialOptions] = None) -> ViamChannel:
+    async def send_request(event: SendRequest):
+        event.metadata["viam_client"] = f"python;v{SDK_VERSION};v{API_VERSION}"
+
     opts = options if options else DialOptions()
     if opts.disable_webrtc:
         channel = await _dial_direct(address, options)
+        listen(channel, SendRequest, send_request)
         return ViamChannel(channel, lambda: None)
     runtime = _Runtime()
     path, path_ptr = await runtime.dial(address, opts)
     if path:
         LOGGER.info(f"Connecting to socket: {path}")
-        chan = Channel(path=path, ssl=None)
+        chan = _create_chan(path)
+        listen(chan, SendRequest, send_request)
 
         def release():
             runtime.free_str(path_ptr)
@@ -259,17 +363,27 @@ async def _dial_direct(address: str, options: Optional[DialOptions] = None) -> C
     if insecure:
         ctx = None
     else:
-        ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)
+        is_local_host = host is not None and (host.startswith("localhost") or host.startswith("0.0.0.0") or host.startswith("127."))
+        if is_local_host:
+            ctx = ssl._create_unverified_context(purpose=ssl.Purpose.SERVER_AUTH)
+        else:
+            ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH)
         ctx.minimum_version = ssl.TLSVersion.TLSv1_2
         ctx.set_ciphers("ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20")
         ctx.set_alpn_protocols(["h2"])
 
-        if options is not None and options.auth_entity and host != options.auth_entity:
+        if (
+            options is not None
+            and options.auth_entity
+            and host != options.auth_entity
+            and options.credentials is not None
+            and options.credentials.type != "api-key"
+        ):
             server_hostname = options.auth_entity
 
         # Test if downgrade is required.
         downgrade = False
-        with socket.create_connection((host, port)) as sock:
+        with socket.create_connection((host, port), timeout=opts.timeout) as sock:
             try:
                 with ctx.wrap_socket(sock, server_hostname=server_hostname) as ssock:
                     _ = ssock.version()
@@ -300,3 +414,7 @@ async def _dial_direct(address: str, options: Optional[DialOptions] = None) -> C
 async def dial_direct(address: str, options: Optional[DialOptions] = None) -> Channel:
     warnings.warn("dial_direct is deprecated. Use rpc.dial.dial instead.", DeprecationWarning, stacklevel=2)
     return await _dial_direct(address, options)
+
+
+async def _dial_app(app_url: str) -> Channel:
+    return await _dial_direct(app_url)

viam/rpc/server.py

@@ -1,3 +1,4 @@
+import sys
 from typing import TYPE_CHECKING, Callable, List, Optional
 
 from grpclib import GRPCError, Status
@@ -6,6 +7,7 @@ from grpclib.const import Handler
 from grpclib.events import RecvRequest, listen
 from grpclib.reflection.service import ServerReflection
 from grpclib.server import Server as GRPCServer
+from grpclib.server import Stream
 from grpclib.utils import graceful_exit
 
 from viam import logging
@@ -40,7 +42,7 @@ class Server(ResourceManager):
         super().__init__(resources)
 
         services = [SignalingService(), RobotService(manager=self)]
-        for registration in Registry.REGISTERED_SUBTYPES().values():
+        for registration in Registry.REGISTERED_APIS().values():
             if issubclass(registration.rpc_service, ResourceRPCServiceBase):
                 services.append(registration.rpc_service(manager=self))
             else:
@@ -53,15 +55,51 @@ class Server(ResourceManager):
 
         self._server = GRPCServer(services)
 
-    async def _grpc_event_handler(self, event: RecvRequest):
+    async def _grpc_recvrequest_handler(self, event: RecvRequest):
         host = None
         port = None
         address = event.peer.addr()
         if address:
             host = address[0]
             port = address[1]
-        msg = f"[gRPC Request] {host or 'xxxx'}:{port or 'xxxx'} - {event.method_name}"
-        LOGGER.debug(msg)
+        method_func = event.method_func
+
+        async def log_resource_name(stream: Stream):
+            recv_msg = stream.recv_message
+
+            async def rcv_and_log_msg():
+                msg = await recv_msg()
+                log_msg = f"[gRPC] Received message from {host or 'xxxx'}:{port or 'xxxx'} - {event.method_name}"
+                if msg and hasattr(msg, "name"):
+                    log_msg += f" for resource named: {msg.name}"
+                LOGGER.debug(log_msg)
+                return msg
+
+            stream.recv_message = rcv_and_log_msg
+            try:
+                return await method_func(stream)
+            finally:
+                LOGGER.debug(f"[gRPC] Finished call from {host or 'xxxx'}:{port or 'xxxx'} - {event.method_name}")
+
+        event.method_func = log_resource_name
+
+    async def _serve(
+        self,
+        host: Optional[str] = "localhost",
+        port: Optional[int] = 9090,
+        log_level: Optional[int] = logging.INFO,
+        *,
+        path: Optional[str] = None,
+    ):
+        if path:
+            await self._server.start(path=path)
+            LOGGER.info(f"Serving on {path}")
+        else:
+            await self._server.start(host, port)
+            LOGGER.info(f"Serving on {host}:{port}")
+        await self._server.wait_closed()
+        await self.close()
+        LOGGER.debug("gRPC server closed")
 
     async def serve(
         self,
@@ -84,17 +122,13 @@ class Server(ResourceManager):
             logging.silence()
         else:
             logging.setLevel(log_level)
-        listen(self._server, RecvRequest, self._grpc_event_handler)
+        listen(self._server, RecvRequest, self._grpc_recvrequest_handler)
 
-        with graceful_exit([self._server]):
-            if path:
-                await self._server.start(path=path)
-                LOGGER.info(f"Serving on {path}")
-            else:
-                await self._server.start(host, port)
-                LOGGER.info(f"Serving on {host}:{port}")
-            await self._server.wait_closed()
-            LOGGER.debug("gRPC server closed")
+        if sys.platform != "win32":
+            with graceful_exit([self._server]):
+                await self._serve(host=host, port=port, log_level=log_level, path=path)
+        else:
+            await self._serve(host=host, port=port, log_level=log_level, path=path)
 
     @classmethod
     async def create_and_serve(
@@ -142,7 +176,17 @@ def _grpc_error_wrapper(func: Callable):
         except ViamGRPCError as e:
             raise e.grpc_error
         except Exception as e:
-            raise GRPCError(Status.UNKNOWN, f"{e.__class__.__name__} - {e}")
+            tb = e.__traceback__
+            file_name = None
+            func_name = None
+            line_num = None
+            # only print the last entry in the stacktrace - not perfect but gives users a starting point
+            while tb is not None:
+                file_name = tb.tb_frame.f_code.co_filename
+                func_name = tb.tb_frame.f_code.co_name
+                line_num = tb.tb_lineno
+                tb = tb.tb_next
+            raise GRPCError(Status.UNKNOWN, f"{e.__class__.__name__} - {e} - {file_name=} {func_name=} {line_num=}")
 
     return interceptor
 

viam/rpc/types.py

@@ -14,11 +14,9 @@ class RPCServiceBase(IServable):
     """
 
     @abstractmethod
-    def __mapping__(self) -> Mapping[str, grpclib.const.Handler]:
-        ...
+    def __mapping__(self) -> Mapping[str, grpclib.const.Handler]: ...
 
 
 @runtime_checkable
 class RPCServiceStubBase(Protocol):
-    def __init__(self, channel: Channel) -> None:
-        ...
+    def __init__(self, channel: Channel) -> None: ...

viam/services/discovery/__init__.py

@@ -0,0 +1,12 @@
+from viam.resource.registry import Registry, ResourceRegistration
+from viam.services.discovery.service import DiscoveryRPCService
+
+from .client import DiscoveryClient
+from .discovery import Discovery
+
+__all__ = [
+    "DiscoveryClient",
+    "Discovery",
+]
+
+Registry.register_api(ResourceRegistration(Discovery, DiscoveryRPCService, lambda name, channel: DiscoveryClient(name, channel)))

viam/services/discovery/client.py

@@ -0,0 +1,55 @@
+from typing import Any, List, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.proto.app.robot import ComponentConfig
+from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.service.discovery import (
+    DiscoverResourcesRequest,
+    DiscoverResourcesResponse,
+    DiscoveryServiceStub,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+
+from .discovery import Discovery
+
+
+class DiscoveryClient(Discovery, ReconfigurableResourceRPCClientBase):
+    """
+    Connect to the Discovery service, which allows you to discover resources on a machine.
+    """
+
+    client: DiscoveryServiceStub
+
+    def __init__(self, name: str, channel: Channel):
+        super().__init__(name)
+        self.channel = channel
+        self.client = DiscoveryServiceStub(channel)
+
+    async def discover_resources(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> List[ComponentConfig]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = DiscoverResourcesRequest(
+            name=self.name,
+            extra=dict_to_struct(extra),
+        )
+        response: DiscoverResourcesResponse = await self.client.DiscoverResources(request, timeout=timeout, metadata=md)
+        return list(response.discoveries)
+
+    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/services/discovery/discovery.py

@@ -0,0 +1,52 @@
+import abc
+from typing import Final, List, Mapping, Optional
+
+from viam.proto.app.robot import ComponentConfig
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
+from viam.utils import ValueTypes
+
+from ..service_base import ServiceBase
+
+
+class Discovery(ServiceBase):
+    """
+    Discovery represents a Discovery service.
+
+    This acts as an abstract base class for any drivers representing specific
+    discovery implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "discovery"
+    )
+
+    @abc.abstractmethod
+    async def discover_resources(
+        self,
+        *,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
+        timeout: Optional[float] = None,
+    ) -> List[ComponentConfig]:
+        """Get all component configs of discovered resources on a machine
+
+        ::
+
+            my_discovery = DiscoveryClient.from_robot(machine, "my_discovery")
+
+            # Get the discovered resources
+            result = await my_discovery.discover_resources(
+                "my_discovery",
+            )
+            discoveries = result.discoveries
+
+        Args:
+            name (str): The name of the discover service
+
+        Returns:
+            List[ComponentConfig]: A list of ComponentConfigs that describe
+            the components found by a discover service
+
+        """
+        ...