viam-sdk 0.55.0__py3-none-win_amd64.whl → 0.56.0__py3-none-win_amd64.whl

viam/services/motion/motion.py

@@ -7,7 +7,7 @@ if sys.version_info >= (3, 10):
 else:
     from typing_extensions import TypeAlias
 
-from viam.proto.common import GeoGeometry, Geometry, GeoPoint, Pose, PoseInFrame, ResourceName, Transform, WorldState
+from viam.proto.common import GeoGeometry, Geometry, GeoPoint, Pose, PoseInFrame, Transform, WorldState
 from viam.proto.service.motion import Constraints, GetPlanResponse, MotionConfiguration, PlanStatusWithID
 from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
 from viam.utils import ValueTypes
@@ -33,7 +33,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def move(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: PoseInFrame,
         world_state: Optional[WorldState] = None,
         constraints: Optional[Constraints] = None,
@@ -44,18 +44,17 @@ class Motion(ServiceBase):
         """Plan and execute a movement to move the component specified to its goal destination.
 
         Note: Frames designated with respect to components can also be used as the ``component_name`` when calling for a move. This
-        technique allows for planning and moving the frame itself to the ``destination``. To do so, simply create a resource name with
-        originating ReferenceFrame's name. Then pass in the resource name into ``component_name``. Ex::
+        technique allows for planning and moving the frame itself to the ``destination``.
+        To do so, simply pass in a string into ``component_name``. Ex::
 
-            resource_name = Gripper.get_resource_name("externalFrame")
-            success = await MotionServiceClient.move(resource_name, ...)
+            success = await MotionServiceClient.move("externalFrame", ...)
 
         ::
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Assumes a gripper configured with name "my_gripper" on the machine
-            gripper_name = Gripper.get_resource_name("my_gripper")
+            # Assumes "my_gripper" on the machine
+            gripper_name = "my_gripper"
             my_frame = "my_gripper_offset"
 
             goal_pose = Pose(x=0, y=0, z=300, o_x=0, o_y=0, o_z=1, theta=0)
@@ -69,7 +68,7 @@ class Motion(ServiceBase):
                                   extra={})
 
         Args:
-            component_name (viam.proto.common.ResourceName): Name of a component on a given robot.
+            component_name (str): Name of a component on a given robot.
             destination (viam.proto.common.PoseInFrame): The destination to move to, expressed as a ``Pose`` and the frame in which it was
                 observed.
             world_state (viam.proto.common.WorldState): When supplied, the motion service will create a plan that obeys any constraints
@@ -95,9 +94,9 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     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,
@@ -120,24 +119,23 @@ class Motion(ServiceBase):
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Get the ResourceNames of the base and movement sensor
-            my_base_resource_name = Base.get_resource_name("my_base")
-            mvmnt_sensor_resource_name = MovementSensor.get_resource_name(
-                "my_movement_sensor")
+            # Get the names of the base and movement sensor
+            my_base_name = "my_base"
+            mvmnt_sensor_name = "my_movement_sensor"
             #  Define a destination GeoPoint at the GPS coordinates [0, 0]
             my_destination = movement_sensor.GeoPoint(latitude=0, longitude=0)
 
             # Move the base component to the designated geographic location, as reported by the movement sensor
             execution_id = await motion.move_on_globe(
-                component_name=my_base_resource_name,
+                component_name=my_base_name,
                 destination=my_destination,
-                movement_sensor_name=mvmnt_sensor_resource_name)
+                movement_sensor_name=mvmnt_sensor_name)
 
         Args:
-            component_name (ResourceName): The ResourceName of the base to move.
+            component_name (str): The name of the base to move.
             destination (GeoPoint): The location of the component's destination, represented in geographic notation as a
                 GeoPoint (lat, lng).
-            movement_sensor_name (ResourceName): The ResourceName of the movement sensor that you want to use to check
+            movement_sensor_name (str): The name of the movement sensor that you want to use to check
                 the machine's location.
             obstacles (Optional[Sequence[GeoGeometry]]): Obstacles to consider when planning the motion of the component,
                 with each represented as a GeoGeometry. Default: None
@@ -170,9 +168,9 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     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,
         *,
@@ -194,23 +192,23 @@ class Motion(ServiceBase):
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Get the ResourceNames of the base component and SLAM service
-            my_base_resource_name = Base.get_resource_name("my_base")
-            my_slam_service_name = SLAMClient.get_resource_name("my_slam_service")
+            # Get the names of the base component and SLAM service
+            my_base_name = "my_base"
+            my_slam_service_name = "my_slam_service"
 
             # Define a destination pose with respect to the origin of the map from the SLAM service "my_slam_service"
             my_pose = Pose(y=10)
 
             # Move the base component to the destination pose of Y=10, a location of
             # (0, 10, 0) in respect to the origin of the map
-            execution_id = await motion.move_on_map(component_name=my_base_resource_name,
+            execution_id = await motion.move_on_map(component_name=my_base_name,
                                                     destination=my_pose,
                                                     slam_service_name=my_slam_service_name)
 
         Args:
-            component_name (ResourceName): The ResourceName of the base to move.
+            component_name (str): The name of the base to move.
             destination (Pose): The destination, which can be any Pose with respect to the SLAM map's origin.
-            slam_service_name (ResourceName): The ResourceName of the SLAM service from which the SLAM map is requested.
+            slam_service_name (str): The name of the SLAM service from which the SLAM map is requested.
             configuration (Optional[MotionConfiguration]): The configuration you want to set across this machine for this motion service.
                 This parameter and each of its fields are optional.
 
@@ -237,7 +235,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def stop_plan(
         self,
-        component_name: ResourceName,
+        component_name: str,
         *,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
@@ -251,11 +249,11 @@ class Motion(ServiceBase):
             # Assuming a `move_on_globe()` started the execution
             # Stop the base component which was instructed to move by `move_on_globe()`
             # or `move_on_map()`
-            my_base_resource_name = Base.get_resource_name("my_base")
+            my_base_name = "my_base"
             await motion.stop_plan(component_name=mvmnt_sensor)
 
         Args:
-            component_name (ResourceName): The component to stop
+            component_name (str): The component to stop
 
         For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#stopplan>`_.
         """
@@ -264,7 +262,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def get_plan(
         self,
-        component_name: ResourceName,
+        component_name: str,
         last_plan_only: bool = False,
         execution_id: Optional[str] = None,
         *,
@@ -291,12 +289,12 @@ class Motion(ServiceBase):
         ::
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
-            my_base_resource_name = Base.get_resource_name("my_base")
+            my_base_name = "my_base"
             # Get the plan(s) of the base component which was instructed to move by `MoveOnGlobe()` or `MoveOnMap()`
-            resp = await motion.get_plan(component_name=my_base_resource_name)
+            resp = await motion.get_plan(component_name=my_base_name)
 
         Args:
-            component_name (ResourceName): The component to stop
+            component_name (str): The component to stop
             last_plan_only (Optional[bool]): If supplied, the response will only return the last plan for the component / execution.
             execution_id (Optional[str]): If supplied, the response will only return plans with the provided execution_id.
 
@@ -343,7 +341,7 @@ class Motion(ServiceBase):
     @abc.abstractmethod
     async def get_pose(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination_frame: str,
         supplemental_transforms: Optional[Sequence[Transform]] = None,
         *,
@@ -359,7 +357,7 @@ class Motion(ServiceBase):
             # (``Arm``, ``Base``, etc).
 
             # Create a `component_name`:
-            component_name = Gripper.get_resource_name("my_gripper")
+            component_name = "my_gripper"
 
             from viam.components.gripper import Gripper
             from viam.services.motion import MotionClient
@@ -368,12 +366,12 @@ class Motion(ServiceBase):
             robot = await connect()
 
             motion = MotionClient.from_robot(robot=machine, name="builtin")
-            gripperName = Gripper.get_resource_name("my_gripper")
+            gripperName = "my_gripper"
             gripperPoseInWorld = await motion.get_pose(component_name=gripperName,
                                                     destination_frame="world")
 
         Args:
-            component_name (viam.proto.common.ResourceName): Name of a component on a robot.
+            component_name (str): Name of a component on a robot.
             destination_frame (str): Name of the desired reference frame.
             supplemental_transforms (Optional[List[viam.proto.common.Transform]]): Transforms used to augment the robot's frame while
                 calculating pose.

viam/services/worldstatestore/worldstatestore.py

@@ -17,7 +17,7 @@ class WorldStateStore(ServiceBase):
     changes to world state transforms, which represent the pose of objects in different
     reference frames. This functionality can be used to create custom visualizations of the world state.
 
-    For more information, see `WorldStateStore service <https://docs.viam.com/dev/reference/apis/services/worldstatestore/>`_.
+    For more information, see `WorldStateStore service <https://docs.viam.com/dev/reference/apis/services/world-state-store/>`_.
     """
 
     API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]

viam/sessions_client.py

@@ -2,6 +2,8 @@ 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
@@ -46,6 +48,7 @@ class SessionsClient:
     _heartbeat_interval: Optional[timedelta]
     _supported: _SupportedState
     _thread: Optional[Thread]
+    _pool: ThreadPoolExecutor
 
     _HEARTBEAT_MONITORED_METHODS: MutableMapping[str, bool] = {}
 
@@ -71,6 +74,7 @@ class SessionsClient:
         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)
@@ -105,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:
@@ -156,17 +166,16 @@ 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")
 
@@ -185,10 +194,10 @@ class SessionsClient:
         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

viam/version_metadata.py

@@ -1,4 +1,4 @@
-__version__ = "0.55.0"
+__version__ = "0.56.0"
 
-API_VERSION = "v0.1.475"
+API_VERSION = "v0.1.477"
 SDK_VERSION = __version__

{viam_sdk-0.55.0.dist-info → viam_sdk-0.56.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viam-sdk
-Version: 0.55.0
+Version: 0.56.0
 Summary: Viam Robotics Python SDK
 Project-URL: Homepage, https://www.viam.com
 Project-URL: Documentation, https://python.viam.dev