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

viam/sessions_client.py

@@ -1,9 +1,14 @@
 import asyncio
+import importlib
+import pkgutil
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import asynccontextmanager
 from copy import deepcopy
 from datetime import timedelta
 from enum import IntEnum
 from threading import Lock, Thread
-from typing import Optional
+from typing import MutableMapping, Optional
 
 from grpclib import Status
 from grpclib.client import Channel
@@ -12,26 +17,13 @@ from grpclib.exceptions import GRPCError, StreamTerminatedError
 from grpclib.metadata import _MetadataLike
 
 from viam import logging
+from viam.gen.common.v1.common_pb2 import safety_heartbeat_monitored
 from viam.proto.robot import RobotServiceStub, SendSessionHeartbeatRequest, StartSessionRequest, StartSessionResponse
 from viam.rpc.dial import DialOptions, dial
 
 LOGGER = logging.getLogger(__name__)
 SESSION_METADATA_KEY = "viam-sid"
 
-EXEMPT_METADATA_METHODS = frozenset(
-    [
-        "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
-        "/proto.rpc.webrtc.v1.SignalingService/Call",
-        "/proto.rpc.webrtc.v1.SignalingService/CallUpdate",
-        "/proto.rpc.webrtc.v1.SignalingService/OptionalWebRTCConfig",
-        "/proto.rpc.v1.AuthService/Authenticate",
-        "/viam.robot.v1.RobotService/ResourceNames",
-        "/viam.robot.v1.RobotService/ResourceRPCSubtypes",
-        "/viam.robot.v1.RobotService/StartSession",
-        "/viam.robot.v1.RobotService/SendSessionHeartbeat",
-    ]
-)
-
 
 class _SupportedState(IntEnum):
     UNKNOWN = 0
@@ -47,7 +39,8 @@ class SessionsClient:
 
     channel: Channel
     client: RobotServiceStub
-    _address: str
+    _address: str  # direct dial address, when using webRTC this is the local socket rather than a robot address
+    _robot_address: Optional[str]  # the actual machine address on app.viam.com. important for creating a sessions client on Windows
     _dial_options: DialOptions
     _disabled: bool
     _lock: Lock
@@ -55,19 +48,33 @@ class SessionsClient:
     _heartbeat_interval: Optional[timedelta]
     _supported: _SupportedState
     _thread: Optional[Thread]
-
-    def __init__(self, channel: Channel, direct_dial_address: str, dial_options: Optional[DialOptions], *, disabled: bool = False):
+    _pool: ThreadPoolExecutor
+
+    _HEARTBEAT_MONITORED_METHODS: MutableMapping[str, bool] = {}
+
+    def __init__(
+        self,
+        channel: Channel,
+        direct_dial_address: str,
+        dial_options: Optional[DialOptions],
+        *,
+        disabled: bool = False,
+        robot_addr: Optional[str] = None,
+    ):
         self.channel = channel
         self.client = RobotServiceStub(channel)
         self._address = direct_dial_address
+        self._robot_address = robot_addr
         self._disabled = disabled
         self._dial_options = deepcopy(dial_options) if dial_options is not None else DialOptions()
-        self._dial_options.disable_webrtc = True
+        if sys.platform != "win32" and sys.platform != "cygwin":
+            self._dial_options.disable_webrtc = True
         self._lock = Lock()
         self._current_id = ""
         self._heartbeat_interval = None
         self._supported = _SupportedState.UNKNOWN
         self._thread = None
+        self._pool = ThreadPoolExecutor()
 
         listen(self.channel, SendRequest, self._send_request)
         listen(self.channel, RecvTrailingMetadata, self._recv_trailers)
@@ -92,7 +99,7 @@ class SessionsClient:
         if self._disabled:
             return
 
-        if event.method_name in EXEMPT_METADATA_METHODS:
+        if not self._is_safety_heartbeat_monitored(event.method_name):
             return
 
         event.metadata.update(await self.metadata)
@@ -102,39 +109,45 @@ class SessionsClient:
             LOGGER.debug("Session expired")
             self.reset()
 
+    @asynccontextmanager
+    async def _acquire_lock_async(self):
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(self._pool, self._lock.acquire)
+        try:
+            yield
+        finally:
+            self._lock.release()
+
     @property
     async def metadata(self) -> _MetadataLike:
-        with self._lock:
+        async with self._acquire_lock_async():
             if self._disabled or self._supported != _SupportedState.UNKNOWN:
                 return self._metadata
 
-        request = StartSessionRequest(resume=self._current_id)
-        try:
-            response: StartSessionResponse = await self.client.StartSession(request)
-        except GRPCError as error:
-            if error.status == Status.UNIMPLEMENTED:
-                with self._lock:
+            request = StartSessionRequest(resume=self._current_id)
+            try:
+                response: StartSessionResponse = await self.client.StartSession(request)
+            except GRPCError as error:
+                if error.status == Status.UNIMPLEMENTED:
                     self._reset()
                     self._supported = _SupportedState.FALSE
                     return self._metadata
-            else:
-                raise
+                else:
+                    raise
 
-        if response is None:
-            raise GRPCError(status=Status.INTERNAL, message="Expected response to start session")
+            if response is None:
+                raise GRPCError(status=Status.INTERNAL, message="Expected response to start session")
 
-        if response.heartbeat_window is None:
-            raise GRPCError(status=Status.INTERNAL, message="Expected heartbeat window in response to start session")
+            if response.heartbeat_window is None:
+                raise GRPCError(status=Status.INTERNAL, message="Expected heartbeat window in response to start session")
 
-        with self._lock:
             self._supported = _SupportedState.TRUE
             self._heartbeat_interval = response.heartbeat_window.ToTimedelta()
             self._current_id = response.id
 
-        # tick once to ensure heartbeats are supported
-        await self._heartbeat_tick(self.client)
+            # tick once to ensure heartbeats are supported
+            await self._heartbeat_tick(self.client)
 
-        with self._lock:
             if self._thread is not None:
                 self._reset()
             if self._supported == _SupportedState.TRUE:
@@ -153,28 +166,38 @@ class SessionsClient:
             return self._metadata
 
     async def _heartbeat_tick(self, client: RobotServiceStub):
-        with self._lock:
-            if not self._current_id:
-                LOGGER.debug("Failed to send heartbeat, session client reset")
-                return
-            request = SendSessionHeartbeatRequest(id=self._current_id)
+        if not self._current_id:
+            LOGGER.debug("Failed to send heartbeat, session client reset")
+            return
+        request = SendSessionHeartbeatRequest(id=self._current_id)
 
         try:
             await client.SendSessionHeartbeat(request)
         except (GRPCError, StreamTerminatedError):
             LOGGER.debug("Heartbeat terminated", exc_info=True)
-            self.reset()
+            self._reset()
         else:
             LOGGER.debug("Sent heartbeat successfully")
 
+    def _get_local_addr(self) -> str:
+        if sys.platform != "win32" and sys.platform != "cygwin":
+            # if we're not on windows, we want the direct dial address
+            return self._address
+
+        # return `robot_address` if it exists, otherwise fallback
+        # when using TCP (i.e., on Windows), we need to create a connection to the actual
+        # robot address for a sessions client to maintain connectivity successfully
+        return self._robot_address if self._robot_address is not None else self._address
+
     async def _heartbeat_process(self, wait: float):
-        channel = await dial(address=self._address, options=self._dial_options)
+        addr = self._get_local_addr()
+        channel = await dial(address=addr, options=self._dial_options)
         client = RobotServiceStub(channel.channel)
         while True:
-            with self._lock:
+            async with self._acquire_lock_async():
                 if self._supported != _SupportedState.TRUE:
                     return
-            await self._heartbeat_tick(client)
+                await self._heartbeat_tick(client)
             await asyncio.sleep(wait)
 
     @property
@@ -183,3 +206,49 @@ class SessionsClient:
             return {SESSION_METADATA_KEY: self._current_id}
 
         return {}
+
+    def _is_safety_heartbeat_monitored(self, method: str) -> bool:
+        if method in self._HEARTBEAT_MONITORED_METHODS:
+            return self._HEARTBEAT_MONITORED_METHODS[method]
+
+        parts = method.split("/")
+        if len(parts) != 3:
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        service_path = parts[1]
+        method_name = parts[2]
+
+        parts = service_path.split(".")
+        if len(parts) < 5:
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        if parts[0] != "viam":
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        resource_type = parts[1]
+        resource_subtype = parts[2]
+        version = parts[3]
+        service_name = parts[4]
+        try:
+            module = importlib.import_module(f"viam.gen.{resource_type}.{resource_subtype}.{version}")
+            submods = pkgutil.iter_modules(module.__path__)
+            for mod in submods:
+                if "_pb2" in mod.name:
+                    submod = getattr(module, mod.name)
+                    DESCRIPTOR = getattr(submod, "DESCRIPTOR")
+                    for service in DESCRIPTOR.services_by_name.values():
+                        if service.name == service_name:
+                            for method_actual in service.methods:
+                                if method_actual.name == method_name:
+                                    options = method_actual.GetOptions()
+                                    if options.HasExtension(safety_heartbeat_monitored):
+                                        is_monitored = options.Extensions[safety_heartbeat_monitored]
+                                        self._HEARTBEAT_MONITORED_METHODS[method] = is_monitored
+                                        return is_monitored
+                                    self._HEARTBEAT_MONITORED_METHODS[method] = False
+                                    return False
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        except Exception:
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False

viam/version_metadata.py

@@ -1,4 +1,4 @@
-__version__ = "0.41.1"
+__version__ = "0.66.0"
 
-API_VERSION = "v0.1.395"
+API_VERSION = "v0.1.507"
 SDK_VERSION = __version__

{viam_sdk-0.41.1.dist-info → viam_sdk-0.66.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viam-sdk
-Version: 0.41.1
+Version: 0.66.0
 Summary: Viam Robotics Python SDK
 Project-URL: Homepage, https://www.viam.com
 Project-URL: Documentation, https://python.viam.dev
@@ -11,7 +11,7 @@ License-File: LICENSE
 Requires-Python: >=3.8.1
 Requires-Dist: googleapis-common-protos>=1.65.0
 Requires-Dist: grpclib>=0.4.7
-Requires-Dist: protobuf==5.29.2
+Requires-Dist: protobuf==5.29.5
 Requires-Dist: pymongo>=4.10.1
 Requires-Dist: typing-extensions>=4.12.2
 Provides-Extra: mlmodel
@@ -38,6 +38,12 @@ Currently, we have pre-built binaries for macOS (both Intel `x86_64` and Apple S
 
 `pip install viam-sdk`
 
+If you want to install on Windows, you can install from github directly with `pip`:
+
+`pip install git+https://github.com/viamrobotics/viam-python-sdk.git`
+
+Note that only direct gRPC connections are supported on Windows; you will need to [disable webrtc](https://python.viam.dev/autoapi/viam/rpc/dial/index.html#viam.rpc.dial.DialOptions.disable_webrtc) or else connection will fail. Full support (including webRTC) _does_ exist on WSL.
+
 If you intend to use the [`MLModel` service](https://python.viam.dev/autoapi/viam/services/mlmodel/mlmodel/index.html#viam.services.mlmodel.mlmodel.MLModel), use the following command instead, which installs additional required dependencies:
 
 `pip install 'viam-sdk[mlmodel]'`
@@ -45,8 +51,6 @@ If you intend to use the [`MLModel` service](https://python.viam.dev/autoapi/via
 You can also run this command on an existing Python SDK install to add support for the ML model service.
 See the [ML (machine learning) model service](https://docs.viam.com/data-ai/ai/deploy/) documentation for more information.
 
-Windows is not supported. If you are using Windows, install `viam-sdk` in WSL. For other unsupported systems, read further on how to install from source.
-
 ### Upgrading
 
 To upgrade, simply run the `pip install` command with the `-U` option:
@@ -88,7 +92,7 @@ To create a client application, to navigate to [app.viam.com](https://app.viam.c
 2. Create a robot (for example `arduino`)
 3. Follow the steps on the setup tab:
 
-   1. Setup Viam App Config on Single Board Computer (SBC)
+   1. Setup machine cloud credentials on Single Board Computer (SBC)
    2. Download and Install Viam Server
    3. Wait until the robot shows as connected. If this doesn't happen try restarting the viam-server:
 
@@ -96,7 +100,7 @@ To create a client application, to navigate to [app.viam.com](https://app.viam.c
       sudo systemctl restart viam-server
       ```
 
-Next, select the `CODE SAMPLE` tab in the Viam Web UI, and copy the boilerplate code from the section labeled `Python SDK`.
+Next, select the `CONNECT` tab in the Viam Web UI, and copy the boilerplate code from the section labeled `Python SDK`.
 
 To ensure the installation succeeded and the systems are functional, save and run this simple program. If the program runs successfully, the python-sdk is properly installed, the `viam-server` instance on your robot is alive, and the computer running the program is able to connect to that instance.