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

viam/services/motion/client.py

@@ -1,22 +1,27 @@
-from typing import Any, Final, List, Mapping, Optional, Sequence
+from typing import Any, Mapping, Optional, Sequence
 
 from grpclib.client import Channel
 
 from viam.proto.common import (
     DoCommandRequest,
     DoCommandResponse,
-    GeoObstacle,
+    GeoGeometry,
+    Geometry,
     GeoPoint,
     Pose,
     PoseInFrame,
-    ResourceName,
     Transform,
     WorldState,
 )
 from viam.proto.service.motion import (
     Constraints,
+    GetPlanRequest,
+    GetPlanResponse,
     GetPoseRequest,
     GetPoseResponse,
+    ListPlanStatusesRequest,
+    ListPlanStatusesResponse,
+    MotionConfiguration,
     MotionServiceStub,
     MoveOnGlobeRequest,
     MoveOnGlobeResponse,
@@ -24,62 +29,40 @@ from viam.proto.service.motion import (
     MoveOnMapResponse,
     MoveRequest,
     MoveResponse,
-    MoveSingleComponentRequest,
-    MoveSingleComponentResponse,
+    PlanStatusWithID,
+    StopPlanRequest,
+    StopPlanResponse,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, Subtype
-from viam.services.service_client_base import ServiceClientBase
 from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
 
+from .motion import Motion
 
-class MotionClient(ServiceClientBase, ReconfigurableResourceRPCClientBase):
-    """Motion is a Viam service that coordinates motion planning across all of the components in a given robot.
 
-    The motion planning service calculates a valid path that avoids self collision by default. If additional constraints are supplied in the
-    ``world_state`` message, the motion planning service will also account for those.
+class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for the Motion service.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "motion")
     client: MotionServiceStub
 
     def __init__(self, name: str, channel: Channel):
-        super().__init__(name, channel)
+        self.channel = channel
         self.client = MotionServiceStub(channel)
+        super().__init__(name)
 
     async def move(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: PoseInFrame,
         world_state: Optional[WorldState] = None,
         constraints: Optional[Constraints] = None,
         *,
         extra: Optional[Mapping[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> bool:
-        """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::
-
-            resource_name = Arm.get_resource_name("externalFrame")
-            success = await MotionServiceClient.move(resource_name, ...)
-
-        Args:
-            component_name (viam.proto.common.ResourceName): 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 contraints
-                expressed in the WorldState message.
-            constraints (viam.proto.service.motion.Constraints): When supplied, the motion service will create a plan that obeys any
-                specified constraints
-
-        Returns:
-            bool: Whether the move was successful
-        """
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = MoveRequest(
             name=self.name,
             destination=destination,
@@ -88,75 +71,24 @@ class MotionClient(ServiceClientBase, ReconfigurableResourceRPCClientBase):
             constraints=constraints,
             extra=dict_to_struct(extra),
         )
-        response: MoveResponse = await self.client.Move(request, timeout=timeout)
-        return response.success
-
-    async def move_single_component(
-        self,
-        component_name: ResourceName,
-        destination: PoseInFrame,
-        world_state: Optional[WorldState] = None,
-        *,
-        extra: Optional[Mapping[str, Any]] = None,
-        timeout: Optional[float] = None,
-    ) -> bool:
-        """
-        This function will pass through a move command to a component with a ``move_to_position`` method that takes a ``Pose``. ``Arm`` is
-        the only component that support this. This method will transform the destination pose, given in an arbitrary frame, into the pose of
-        the arm. The arm will then move its most distal link to that pose. If you instead wish to move any other component than the arm end
-        to that pose, then you must manually adjust the given destination by the transform from the arm end to the intended component.
-
-        Args:
-            component_name (viam.proto.common.ResourceName): 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 contraints
-                expressed in the WorldState message.
-
-        Returns:
-            bool: Whether the move was successful
-        """
-        if extra is None:
-            extra = {}
-        request = MoveSingleComponentRequest(
-            name=self.name,
-            destination=destination,
-            component_name=component_name,
-            world_state=world_state,
-            extra=dict_to_struct(extra),
-        )
-        response: MoveSingleComponentResponse = await self.client.MoveSingleComponent(request, timeout=timeout)
+        response: MoveResponse = await self.client.Move(request, timeout=timeout, metadata=md)
         return response.success
 
     async def move_on_globe(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: GeoPoint,
-        movement_sensor_name: ResourceName,
-        obstacles: Optional[Sequence[GeoObstacle]] = None,
+        movement_sensor_name: str,
+        obstacles: Optional[Sequence[GeoGeometry]] = None,
         heading: Optional[float] = None,
-        linear_meters_per_sec: Optional[float] = None,
-        angular_deg_per_sec: Optional[float] = None,
+        configuration: Optional[MotionConfiguration] = None,
         *,
+        bounding_regions: Optional[Sequence[GeoGeometry]] = None,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
-    ) -> bool:
-        """Move a component to a specific latitude and longitude, using a ``MovementSensor`` to check the location.
-
-        Args:
-            component_name (ResourceName): The component to move
-            destination (GeoPoint): The destination point
-            movement_sensor_name (ResourceName): The ``MovementSensor`` which will be used to check robot location
-            obstacles (Optional[Sequence[GeoObstacle]], optional): Obstacles to be considered for motion planning. Defaults to None.
-            heading (Optional[float], optional): Compass heading to achieve at the destination, in degrees [0-360). Defaults to None.
-            linear_meters_per_sec (Optional[float], optional): Linear velocity to target when moving. Defaults to None.
-            angular_deg_per_sec (Optional[float], optional): Angular velocity to target when turning. Defaults to None.
-
-        Returns:
-            bool: Whether the request was successful
-        """
-        if extra is None:
-            extra = {}
+        **kwargs,
+    ) -> str:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = MoveOnGlobeRequest(
             name=self.name,
             component_name=component_name,
@@ -164,73 +96,107 @@ class MotionClient(ServiceClientBase, ReconfigurableResourceRPCClientBase):
             movement_sensor_name=movement_sensor_name,
             obstacles=obstacles,
             heading=heading,
-            linear_meters_per_sec=linear_meters_per_sec,
-            angular_deg_per_sec=angular_deg_per_sec,
+            motion_configuration=configuration,
+            bounding_regions=bounding_regions,
             extra=dict_to_struct(extra),
         )
-        response: MoveOnGlobeResponse = await self.client.MoveOnGlobe(request, timeout=timeout)
-        return response.success
+        response: MoveOnGlobeResponse = await self.client.MoveOnGlobe(request, timeout=timeout, metadata=md)
+        return response.execution_id
 
     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,
         *,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
-    ) -> bool:
-        """Move a component to a specific pose, using a ``SlamService`` for the SLAM map
-
-        Args:
-            component_name (ResourceName): The component to move
-            destination (Pose): The destination, which can be any pose with respect to the SLAM map's origin
-            slam_service_name (ResourceName): The slam service from which the SLAM map is requested
-
-        Returns:
-            bool: Whether the request was successful
-        """
-        if extra is None:
-            extra = {}
+        **kwargs,
+    ) -> str:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = MoveOnMapRequest(
             name=self.name,
             destination=destination,
             component_name=component_name,
             slam_service_name=slam_service_name,
+            motion_configuration=configuration,
+            obstacles=obstacles,
             extra=dict_to_struct(extra),
         )
-        response: MoveOnMapResponse = await self.client.MoveOnMap(request, timeout=timeout)
-        return response.success
+        response: MoveOnMapResponse = await self.client.MoveOnMap(request, timeout=timeout, metadata=md)
+        return response.execution_id
 
-    async def get_pose(
+    async def stop_plan(
         self,
-        component_name: ResourceName,
-        destination_frame: str,
-        supplemental_transforms: Optional[List[Transform]] = None,
+        component_name: str,
         *,
-        extra: Optional[Mapping[str, Any]] = None,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
-    ) -> PoseInFrame:
-        """
-        Get the Pose and observer frame for any given component on a robot. A ``component_name`` can be created like this::
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
 
-            component_name = Arm.get_resource_name("arm")
+        request = StopPlanRequest(
+            name=self.name,
+            component_name=component_name,
+            extra=dict_to_struct(extra),
+        )
+        _: StopPlanResponse = await self.client.StopPlan(request, timeout=timeout, metadata=md)
+        return
 
-        Note that the example uses the ``Arm`` class, but any component class that inherits from ``ComponentBase`` will work
-        (``Base``, ``Gripper``, etc).
+    async def get_plan(
+        self,
+        component_name: str,
+        last_plan_only: bool = False,
+        execution_id: Optional[str] = None,
+        *,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> GetPlanResponse:
+        md = kwargs.get("metadata", self.Metadata()).proto
 
+        request = GetPlanRequest(
+            name=self.name,
+            component_name=component_name,
+            last_plan_only=last_plan_only,
+            execution_id=execution_id,
+            extra=dict_to_struct(extra),
+        )
+        response: GetPlanResponse = await self.client.GetPlan(request, timeout=timeout, metadata=md)
+        return response
 
-        Args:
-            component_name (viam.proto.common.ResourceName): 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.
+    async def list_plan_statuses(
+        self,
+        only_active_plans: bool = False,
+        *,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Sequence[PlanStatusWithID]:
+        md = kwargs.get("metadata", self.Metadata()).proto
 
-        Returns:
-            ``Pose`` (PoseInFrame): Pose of the given component and the frame in which it was observed.
-        """
-        if extra is None:
-            extra = {}
+        request = ListPlanStatusesRequest(
+            name=self.name,
+            only_active_plans=only_active_plans,
+            extra=dict_to_struct(extra),
+        )
+        response: ListPlanStatusesResponse = await self.client.ListPlanStatuses(request, timeout=timeout, metadata=md)
+        return response.plan_statuses_with_ids
+
+    async def get_pose(
+        self,
+        component_name: str,
+        destination_frame: str,
+        supplemental_transforms: Optional[Sequence[Transform]] = None,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> PoseInFrame:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPoseRequest(
             name=self.name,
             component_name=component_name,
@@ -238,18 +204,11 @@ class MotionClient(ServiceClientBase, ReconfigurableResourceRPCClientBase):
             supplemental_transforms=supplemental_transforms,
             extra=dict_to_struct(extra),
         )
-        response: GetPoseResponse = await self.client.GetPose(request, timeout=timeout)
+        response: GetPoseResponse = await self.client.GetPose(request, timeout=timeout, metadata=md)
         return response.pose
 
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None) -> Mapping[str, ValueTypes]:
-        """Send/receive arbitrary commands
-
-        Args:
-            command (Dict[str, ValueTypes]): The command to execute
-
-        Returns:
-            Dict[str, ValueTypes]: Result of the executed command
-        """
+    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)