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

viam/resource/easy_resource.py

@@ -1,7 +1,7 @@
 import inspect
 import re
 from abc import ABCMeta
-from typing import Callable, ClassVar, Mapping, Sequence, Union
+from typing import Callable, ClassVar, Mapping, Sequence, Tuple, Union
 
 from viam.proto.app.robot import ComponentConfig
 from viam.proto.common import ResourceName
@@ -113,16 +113,15 @@ class EasyResource:
     @classmethod
     def new(cls, config: ComponentConfig, dependencies: Mapping[ResourceName, ResourceBase]):
         """
-        This is passed to register_resource_creator; the default implementation calls reconfigure()
+        This is passed to register_resource_creator. The default implementation only sets the resource name
         when an instance of your model is instantiated. You can override this in your subclass.
         """
         self = cls(config.name)
         logger.debug("created %s %s %s", cls.API, cls.MODEL, config.name)
-        self.reconfigure(config, dependencies)
         return self
 
     @classmethod
-    def validate_config(cls, config: ComponentConfig) -> Sequence[str]:
+    def validate_config(cls, config: ComponentConfig) -> Tuple[Sequence[str], Sequence[str]]:
         """This method allows you to validate the configuration object received from the machine,
         as well as to return any implicit dependencies based on that `config`.
 
@@ -130,9 +129,9 @@ class EasyResource:
             config (ComponentConfig): The configuration for this resource
 
         Returns:
-            Sequence[str]: A list of implicit dependencies
+            Tuple[Sequence[str], Sequence[str]]: One list of required implicit dependencies and one of optional deps.
         """
-        return []
+        return [], []
 
     @classmethod
     def register(cls):
@@ -148,6 +147,3 @@ class EasyResource:
             cls.MODEL,
             ResourceCreatorRegistration(cls.new, cls.validate_config),  # pyright: ignore [reportArgumentType]
         )
-
-    def reconfigure(self, config: ComponentConfig, dependencies: Mapping[ResourceName, ResourceBase]):
-        logger.debug("reconfigure %s %s", self.API, self.MODEL)

viam/resource/manager.py

@@ -103,10 +103,11 @@ class ResourceManager:
             try:
                 resource = self.resources[name]
                 await resource.close()
-            except Exception as e:
-                raise e
             finally:
-                del self.resources[name]
+                try:
+                    del self.resources[name]
+                except KeyError:
+                    pass
 
     async def close(self):
         """Close the resourcce manager by removing all resources.

viam/resource/registry.py

@@ -27,7 +27,7 @@ class ResourceCreatorRegistration:
     """A function that can create a resource given a mapping of dependencies (``ResourceName`` to ``ResourceBase``
     """
 
-    validator: "Validator" = lambda x: []
+    validator: "Validator" = lambda x: ([], [])
     """A function that can validate a resource and return implicit dependencies.
 
     If called without a validator function, default to a function returning an empty Sequence
@@ -170,7 +170,7 @@ class Registry:
         try:
             return cls._RESOURCES[f"{api}/{model}"].validator
         except AttributeError:
-            return lambda x: []
+            return lambda x: ([], [])
         except KeyError:
             raise ResourceNotFoundError(api.resource_type, api.resource_subtype)
 

viam/resource/types.py

@@ -1,6 +1,6 @@
 import re
 import sys
-from typing import TYPE_CHECKING, Callable, ClassVar, Mapping, Optional, Protocol, Sequence, runtime_checkable
+from typing import TYPE_CHECKING, Callable, ClassVar, Mapping, Optional, Protocol, Sequence, Tuple, runtime_checkable
 
 if sys.version_info >= (3, 10):
     from typing import TypeAlias
@@ -203,7 +203,7 @@ def resource_name_from_string(string: str) -> ResourceName:
 
 
 ResourceCreator: TypeAlias = Callable[[ComponentConfig, Mapping[ResourceName, "ResourceBase"]], "ResourceBase"]
-Validator: TypeAlias = Callable[[ComponentConfig], Sequence[str]]
+Validator: TypeAlias = Callable[[ComponentConfig], Tuple[Sequence[str], Sequence[str]]]
 
 
 @runtime_checkable

viam/robot/client.py

@@ -1,6 +1,5 @@
 import asyncio
 import sys
-import warnings
 from dataclasses import dataclass
 from datetime import datetime
 from threading import RLock
@@ -18,10 +17,6 @@ from viam.proto.common import LogEntry, PoseInFrame, ResourceName, Transform
 from viam.proto.robot import (
     BlockForOperationRequest,
     CancelOperationRequest,
-    DiscoverComponentsRequest,
-    DiscoverComponentsResponse,
-    Discovery,
-    DiscoveryQuery,
     FrameSystemConfig,
     FrameSystemConfigRequest,
     FrameSystemConfigResponse,
@@ -40,6 +35,7 @@ from viam.proto.robot import (
     Operation,
     ResourceNamesRequest,
     ResourceNamesResponse,
+    RestartModuleRequest,
     RobotServiceStub,
     ShutdownRequest,
     StopAllRequest,
@@ -52,7 +48,7 @@ from viam.resource.manager import ResourceManager
 from viam.resource.registry import Registry
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase, ResourceRPCClientBase
 from viam.resource.types import API, RESOURCE_TYPE_COMPONENT, RESOURCE_TYPE_SERVICE
-from viam.rpc.dial import DialOptions, ViamChannel, dial
+from viam.rpc.dial import DialOptions, ViamChannel, _dial_inner, dial
 from viam.services.service_base import ServiceBase
 from viam.sessions_client import SessionsClient
 from viam.utils import datetime_to_timestamp, dict_to_struct
@@ -189,7 +185,7 @@ class RobotClient:
                     # Replace "<API-KEY-ID>" (including brackets) with your machine's API key ID
                     api_key_id='<API-KEY-ID>'
                 )
-                return await RobotClient.at_address('ADDRESS FROM THE VIAM APP', opts)
+                return await RobotClient.at_address('MACHINE ADDRESS', opts)
 
 
             async def main():
@@ -207,7 +203,7 @@ class RobotClient:
         """
         logging.setLevel(options.log_level)
         channel = await dial(address, options.dial_options)
-        machine = await cls._with_channel(channel, options, True)
+        machine = await cls._with_channel(channel, options, True, robot_addr=address)
         machine._address = address
         return machine
 
@@ -242,7 +238,9 @@ class RobotClient:
         return await cls._with_channel(channel, options, False)
 
     @classmethod
-    async def _with_channel(cls, channel: Union[Channel, ViamChannel], options: Options, close_channel: bool):
+    async def _with_channel(
+        cls, channel: Union[Channel, ViamChannel], options: Options, close_channel: bool, robot_addr: Optional[str] = None
+    ):
         """INTERNAL USE ONLY"""
 
         self = cls()
@@ -263,7 +261,7 @@ class RobotClient:
         self._options = options
         self._address = self._channel._path if self._channel._path else f"{self._channel._host}:{self._channel._port}"
         self._sessions_client = SessionsClient(
-            self._channel, self._address, self._options.dial_options, disabled=self._options.disable_sessions
+            self._channel, self._address, self._options.dial_options, disabled=self._options.disable_sessions, robot_addr=robot_addr
         )
 
         try:
@@ -403,7 +401,7 @@ class RobotClient:
                 try:
                     self._sessions_client.reset()
 
-                    channel = await dial(self._address, self._options.dial_options)
+                    channel = await _dial_inner(self._address, self._options.dial_options)
 
                     client: RobotServiceStub
                     if isinstance(channel, Channel):
@@ -425,6 +423,7 @@ class RobotClient:
                         direct_dial_address=direct_dial_address,
                         dial_options=self._options.dial_options,
                         disabled=self._options.disable_sessions,
+                        robot_addr=self._address,
                     )
 
                     await self.refresh()
@@ -727,53 +726,6 @@ class RobotClient:
     async def transform_point_cloud(self):
         raise NotImplementedError()
 
-    #######################
-    # COMPONENT DISCOVERY #
-    #######################
-
-    async def discover_components(
-        self,
-        queries: List[DiscoveryQuery],
-    ) -> List[Discovery]:
-        """
-        Deprecated: v0.38.0, use the Discovery Service APIs instead.
-        Get a list of discovered potential component configurations, for example listing different supported resolutions. Currently only works for some cameras.
-        Returns module names for modules.
-
-        ::
-
-            from viam.proto.robot import DiscoveryQuery
-
-            # Define a new discovery query.
-            q = DiscoveryQuery(subtype="camera", model="webcam")
-
-            # Define a list of discovery queries.
-            qs = [q]
-
-            # Get component configurations with these queries.
-            component_configs = await machine.discover_components(qs)
-
-        Args:
-
-            queries (List[viam.proto.robot.DiscoveryQuery]): The list of component models to lookup potential configurations for.
-
-        Returns:
-            List[Discovery]: A list of discovered potential component configurations.
-
-        For more information, see `Machine Management API <https://docs.viam.com/appendix/apis/robot/>`_.
-        """
-        request = DiscoverComponentsRequest(queries=queries)
-        response: DiscoverComponentsResponse = await self._client.DiscoverComponents(request)
-        warnings.warn(
-            "RobotClient.discover_components is deprecated. It will be removed on March 10 2025. Use the DiscoveryService APIs instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        LOGGER.warning(
-            "RobotClient.discover_components is deprecated. It will be removed on March 10 2025. Use the DiscoveryService APIs instead."
-        )
-        return list(response.discovery)
-
     #################
     # MODULE MODELS #
     #################
@@ -949,10 +901,37 @@ class RobotClient:
             config_status = machine_status.config
 
         Returns:
-            viam.proto.robot.GetMachineStatusResponse: current status of the machine (initializing or running), resources (List[ResourceStatus]) and config of the machine.
+            viam.proto.robot.GetMachineStatusResponse: current status of the machine (initializing or running), current status of the resources (List[ResourceStatus]) and the revision of the config of the machine.
 
         For more information, see `Machine Management API <https://docs.viam.com/appendix/apis/robot/>`_.
         """
 
         request = GetMachineStatusRequest()
         return await self._client.GetMachineStatus(request)
+
+    ##################
+    # Restart Module #
+    ##################
+
+    async def restart_module(self, id: Optional[str] = None, name: Optional[str] = None):
+        """
+        Restarts a module running on the machine with the given id or name.
+
+        ::
+
+            await machine.restart_module(id="namespace:module:model", name="my_model")
+
+        Args:
+            id (str): The id matching the module_id field of the registry module in your part configuration.
+            name (str): The name matching the name field of the local/registry module in your part configuration.
+
+        Raises:
+            GRPCError: If a module can't be found matching the provided ID or name.
+
+        For more information, see `Machine Management API <https://docs.viam.com/appendix/apis/robot/>`_.
+        """
+
+        id = id if id else ""
+        name = name if name else ""
+        request = RestartModuleRequest(module_id=id, module_name=name)
+        await self._client.RestartModule(request)

viam/rpc/dial.py

@@ -29,9 +29,9 @@ LOGGER = logging.getLogger(__name__)
 
 @dataclass
 class Credentials:
-    """Credentials to connect to the robot and the Viam app."""
+    """Credentials to connect to the machine and app.viam.com."""
 
-    type: Union[Literal["robot-location-secret"], Literal["robot-secret"], Literal["api-key"]]
+    type: Union[Literal["robot-secret"], Literal["api-key"]]
     """The type of credential
     """
 
@@ -70,6 +70,14 @@ class DialOptions:
     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"""
@@ -85,6 +93,8 @@ class DialOptions:
         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
@@ -94,6 +104,8 @@ class DialOptions:
         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:
@@ -220,8 +232,9 @@ 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
@@ -279,8 +292,38 @@ 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}"
+        event.metadata["viam_client"] = f"python;v{SDK_VERSION};v{API_VERSION}"
 
     opts = options if options else DialOptions()
     if opts.disable_webrtc:
@@ -291,7 +334,7 @@ async def dial(address: str, options: Optional[DialOptions] = None) -> ViamChann
     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():

viam/rpc/server.py

@@ -1,3 +1,4 @@
+import sys
 from typing import TYPE_CHECKING, Callable, List, Optional
 
 from grpclib import GRPCError, Status
@@ -82,6 +83,24 @@ class Server(ResourceManager):
 
         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,
         host: Optional[str] = "localhost",
@@ -105,16 +124,11 @@ class Server(ResourceManager):
             logging.setLevel(log_level)
         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()
-            await self.close()
-            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(

viam/services/motion/client.py

@@ -10,7 +10,6 @@ from viam.proto.common import (
     GeoPoint,
     Pose,
     PoseInFrame,
-    ResourceName,
     Transform,
     WorldState,
 )
@@ -54,7 +53,7 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
 
     async def move(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: PoseInFrame,
         world_state: Optional[WorldState] = None,
         constraints: Optional[Constraints] = None,
@@ -77,9 +76,9 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
 
     async def move_on_globe(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: GeoPoint,
-        movement_sensor_name: ResourceName,
+        movement_sensor_name: str,
         obstacles: Optional[Sequence[GeoGeometry]] = None,
         heading: Optional[float] = None,
         configuration: Optional[MotionConfiguration] = None,
@@ -106,9 +105,9 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
 
     async def move_on_map(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: Pose,
-        slam_service_name: ResourceName,
+        slam_service_name: str,
         configuration: Optional[MotionConfiguration] = None,
         obstacles: Optional[Sequence[Geometry]] = None,
         *,
@@ -131,7 +130,7 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
 
     async def stop_plan(
         self,
-        component_name: ResourceName,
+        component_name: str,
         *,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
@@ -149,7 +148,7 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
 
     async def get_plan(
         self,
-        component_name: ResourceName,
+        component_name: str,
         last_plan_only: bool = False,
         execution_id: Optional[str] = None,
         *,
@@ -189,7 +188,7 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
 
     async def get_pose(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination_frame: str,
         supplemental_transforms: Optional[Sequence[Transform]] = None,
         *,