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

viam/services/motion/motion.py

@@ -0,0 +1,380 @@
+import abc
+import sys
+from typing import Any, Final, Mapping, Optional, Sequence
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+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
+
+from ..service_base import ServiceBase
+
+
+class Motion(ServiceBase):
+    """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.
+
+    For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/>`_.
+    """
+
+    Plan: "TypeAlias" = GetPlanResponse
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "motion"
+    )
+
+    @abc.abstractmethod
+    async def move(
+        self,
+        component_name: str,
+        destination: PoseInFrame,
+        world_state: Optional[WorldState] = None,
+        constraints: Optional[Constraints] = None,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> 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 pass in a string into ``component_name``. Ex::
+
+            success = await MotionServiceClient.move("externalFrame", ...)
+
+        ::
+
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+
+            # 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)
+
+            # Move the gripper
+            moved = await motion.move(component_name=gripper_name,
+                                  destination=PoseInFrame(reference_frame="myFrame",
+                                                          pose=goal_pose),
+                                  world_state=worldState,
+                                  constraints={},
+                                  extra={})
+
+        Args:
+            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
+                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. These can include:
+                - LinearConstraint: Specifies that the component being moved should move linearly relative to its goal.
+                - OrientationConstraint: Specifies that the component being moved will not deviate its orientation beyond some threshold
+                  relative to the goal.
+                - CollisionSpecification: Used to selectively apply obstacle avoidance to specific parts of the robot.
+                - PseudolinearConstraint: Specifies that the component being moved should not deviate from the straight-line path to their
+                  goal by more than a factor proportional to the distance from start to goal. For example, if a component is moving 100mm,
+                  then a LineToleranceFactor of 1.0 means that the component will remain within a 100mm radius of the straight-line
+                  start-goal path.
+
+        Returns:
+            bool: Whether the move was successful.
+
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#move>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def move_on_globe(
+        self,
+        component_name: str,
+        destination: GeoPoint,
+        movement_sensor_name: str,
+        obstacles: Optional[Sequence[GeoGeometry]] = None,
+        heading: Optional[float] = None,
+        configuration: Optional[MotionConfiguration] = None,
+        *,
+        bounding_regions: Optional[Sequence[GeoGeometry]] = None,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
+        timeout: Optional[float] = None,
+    ) -> str:
+        """Move a component to a specific latitude and longitude, using a ``MovementSensor`` to check the location.
+
+        ``move_on_globe()`` is non blocking, meaning the motion service will move the component to the destination
+        GPS point after ``move_on_globe()`` returns.
+
+        Each successful ``move_on_globe()`` call returns a unique ExecutionID which you can use to identify all plans
+        generated during the ``move_on_globe()`` call.
+
+        You can monitor the progress of the ``move_on_globe()`` call by querying ``get_plan()`` and ``list_plan_statuses()``.
+
+        ::
+
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+
+            # 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_name,
+                destination=my_destination,
+                movement_sensor_name=mvmnt_sensor_name)
+
+        Args:
+            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 (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
+            heading (Optional[float]): The compass heading, in degrees, that the machine's movement sensor should report
+                at the destination point. Range: [0-360) 0: North, 90: East, 180: South, 270: West. Default: None
+            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.
+
+                - obstacle_detectors (Sequence[ObstacleDetector]): The names of each vision service and camera resource pair
+                you want to use for transient obstacle avoidance.
+
+                - position_polling_frequency_hz (float): The frequency in Hz to poll the position of the machine.
+                - obstacle_polling_frequency_hz (float): The frequency in Hz to poll the vision service for new obstacles.
+                - plan_deviation_m (float): The distance in meters that the machine can deviate from the motion plan.
+                - linear_m_per_sec (float): Linear velocity this machine should target when moving.
+                - angular_degs_per_sec (float): Angular velocity this machine should target when turning.
+            bounding_regions (Optional[Sequence[GeoGeometry]]): Set of obstacles which the robot must remain within while navigating
+            extra (Optional[Dict[str, Any]]): Extra options to pass to the underlying RPC call.
+            timeout (Optional[float]): An option to set how long to wait (in seconds) before calling a time-out and closing
+                the underlying RPC call.
+
+
+        Returns:
+            str: ExecutionID of the ``move_on_globe()`` call, which can be used to track execution progress.
+
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#moveonglobe>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def move_on_map(
+        self,
+        component_name: str,
+        destination: Pose,
+        slam_service_name: str,
+        configuration: Optional[MotionConfiguration] = None,
+        obstacles: Optional[Sequence[Geometry]] = None,
+        *,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
+        timeout: Optional[float] = None,
+    ) -> str:
+        """
+        Move a component to a specific pose, using a ``SlamService`` for the SLAM map, using a ``SLAM Service`` to check the location.
+
+        ``move_on_map()`` is non blocking, meaning the motion service will move the component to the destination
+        Pose point after ``move_on_map()`` returns.
+
+        Each successful ``move_on_map()`` call returns a unique ExecutionID which you can use to identify all plans
+        generated during the ``move_on_map()`` call.
+
+        You can monitor the progress of the ``move_on_map()`` call by querying ``get_plan()`` and ``list_plan_statuses()``.
+
+        ::
+
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+
+            # 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_name,
+                                                    destination=my_pose,
+                                                    slam_service_name=my_slam_service_name)
+
+        Args:
+            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 (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.
+
+                - obstacle_detectors (Sequence[ObstacleDetector]): The names of each vision service and camera resource pair you want to use
+                for transient obstacle avoidance.
+
+                - position_polling_frequency_hz (float): The frequency in hz to poll the position of the machine.
+                - obstacle_polling_frequency_hz (float): The frequency in hz to poll the vision service for new obstacles.
+                - plan_deviation_m (float): The distance in meters that the machine can deviate from the motion plan.
+                - linear_m_per_sec (float): Linear velocity this machine should target when moving.
+                - angular_degs_per_sec (float): Angular velocity this machine should target when turning.
+            obstacles (Optional[Sequence[Geometry]]): Obstacles to be considered for motion planning.
+            extra (Optional[Dict[str, Any]]): Extra options to pass to the underlying RPC call.
+            timeout (Optional[float]): An option to set how long to wait (in seconds) before calling a time-out and closing the underlying
+                RPC call.
+
+        Returns:
+            str: ExecutionID of the ``move_on_map()`` call, which can be used to track execution progress.
+
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#moveonmap>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def stop_plan(
+        self,
+        component_name: str,
+        *,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
+        timeout: Optional[float] = None,
+    ):
+        """Stop a component being moved by an in progress ``move_on_globe()`` or ``move_on_map()`` call.
+
+        ::
+
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+
+            # 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_name = "my_base"
+            await motion.stop_plan(component_name=mvmnt_sensor)
+
+        Args:
+            component_name (str): The component to stop
+
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#stopplan>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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,
+    ) -> Plan:
+        """By default: returns the plan history of the most recent ``move_on_globe()`` or ``move_on_map()`` call to move a component.
+
+        The plan history for executions before the most recent can be requested by providing an ExecutionID in the request.
+
+        Returns a result if both of the following conditions are met:
+
+        - the execution (call to ``move_on_globe()`` or ``move_on_map()``) is still executing **or** changed state within the last 24 hours
+        - the robot has not reinitialized
+
+        Plans never change.
+
+        Replans always create new plans.
+
+        Replans share the ExecutionID of the previously executing plan.
+
+        All repeated fields are in time ascending order.
+
+        ::
+
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+            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_name)
+
+        Args:
+            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.
+
+        Returns:
+            ``GetPlanResponse`` (GetPlanResponse): The current PlanWithStatus & replan history which matches the request
+
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#getplan>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def list_plan_statuses(
+        self,
+        only_active_plans: bool = False,
+        *,
+        extra: Optional[Mapping[str, ValueTypes]] = None,
+        timeout: Optional[float] = None,
+    ) -> Sequence[PlanStatusWithID]:
+        """Returns the statuses of plans created by `move_on_globe()` or ``move_on_map()`` calls that meet at least one of the following
+        conditions since the motion service initialized:
+
+        - the plan's status is in progress
+        - the plan's status changed state within the last 24 hours
+
+        All repeated fields are in chronological order.
+
+        ::
+
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+            # List the plan statuses of the motion service within the TTL
+            resp = await motion.list_plan_statuses()
+
+        Args:
+            only_active_plans (Optional[bool]):  If supplied, the response will filter out any plans that are not executing.
+
+        Returns:
+            ``ListPlanStatusesResponse`` (ListPlanStatusesResponse): List of last known statuses with the
+            associated IDs of all plans within the TTL ordered by timestamp in ascending order.
+
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#listplanstatuses>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    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,
+    ) -> PoseInFrame:
+        """
+        Get the Pose and observer frame for any given component on a robot.
+
+        ::
+
+            # Note that the example uses the ``Gripper`` class, but any component class that inherits from ``ComponentBase`` will work
+            # (``Arm``, ``Base``, etc).
+
+            from viam.components.gripper import Gripper
+            from viam.services.motion import MotionClient
+
+            # Assume that the connect function is written and will return a valid machine.
+            machine = await connect()
+
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+            gripperPoseInWorld = await motion.get_pose(component_name="my_gripper",
+                                                       destination_frame="world")
+
+        Args:
+            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.
+
+        Returns:
+            ``Pose`` (PoseInFrame): Pose of the given component and the frame in which it was observed.
+
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#getpose>`_.
+        """
+        ...

viam/services/motion/service.py

@@ -0,0 +1,132 @@
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.service.motion import (
+    GetPlanRequest,
+    GetPlanResponse,
+    GetPoseRequest,
+    GetPoseResponse,
+    ListPlanStatusesRequest,
+    ListPlanStatusesResponse,
+    MoveOnGlobeRequest,
+    MoveOnGlobeResponse,
+    MoveOnMapRequest,
+    MoveOnMapResponse,
+    MoveRequest,
+    MoveResponse,
+    StopPlanRequest,
+    StopPlanResponse,
+    UnimplementedMotionServiceBase,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .motion import Motion
+
+
+class MotionRPCService(UnimplementedMotionServiceBase, ResourceRPCServiceBase[Motion]):
+    RESOURCE_TYPE = Motion
+
+    async def Move(self, stream: Stream[MoveRequest, MoveResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await service.move(
+            request.component_name,
+            request.destination,
+            request.world_state,
+            request.constraints,
+            extra=struct_to_dict(request.extra),
+            timeout=timeout,
+        )
+        response = MoveResponse(success=result)
+        await stream.send_message(response)
+
+    async def MoveOnMap(self, stream: Stream[MoveOnMapRequest, MoveOnMapResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await service.move_on_map(
+            request.component_name,
+            request.destination,
+            request.slam_service_name,
+            request.motion_configuration,
+            request.obstacles,
+            extra=struct_to_dict(request.extra),
+            timeout=timeout,
+        )
+        response = MoveOnMapResponse(execution_id=result)
+        await stream.send_message(response)
+
+    async def MoveOnGlobe(self, stream: Stream[MoveOnGlobeRequest, MoveOnGlobeResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await service.move_on_globe(
+            request.component_name,
+            request.destination,
+            request.movement_sensor_name,
+            request.obstacles,
+            request.heading,
+            request.motion_configuration,
+            bounding_regions=request.bounding_regions,
+            extra=struct_to_dict(request.extra),
+            timeout=timeout,
+        )
+        response = MoveOnGlobeResponse(execution_id=result)
+        await stream.send_message(response)
+
+    async def GetPose(self, stream: Stream[GetPoseRequest, GetPoseResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await service.get_pose(
+            request.component_name,
+            request.destination_frame,
+            request.supplemental_transforms,
+            extra=struct_to_dict(request.extra),
+            timeout=timeout,
+        )
+        response = GetPoseResponse(pose=result)
+        await stream.send_message(response)
+
+    async def StopPlan(self, stream: Stream[StopPlanRequest, StopPlanResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await service.stop_plan(request.component_name, extra=struct_to_dict(request.extra), timeout=timeout)
+        response = StopPlanResponse()
+        await stream.send_message(response)
+
+    async def ListPlanStatuses(self, stream: Stream[ListPlanStatusesRequest, ListPlanStatusesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await service.list_plan_statuses(request.only_active_plans, extra=struct_to_dict(request.extra), timeout=timeout)
+        response = ListPlanStatusesResponse(plan_statuses_with_ids=result)
+        await stream.send_message(response)
+
+    async def GetPlan(self, stream: Stream[GetPlanRequest, GetPlanResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await service.get_plan(
+            request.component_name, request.last_plan_only, request.execution_id, extra=struct_to_dict(request.extra), timeout=timeout
+        )
+        await stream.send_message(result)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        service = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await service.do_command(struct_to_dict(request.command), timeout=timeout, metadata=stream.metadata)
+        response = DoCommandResponse(result=dict_to_struct(result))
+        await stream.send_message(response)

viam/services/navigation/__init__.py

@@ -0,0 +1,11 @@
+from viam.proto.common import GeoGeometry, GeoPoint
+from viam.proto.service.navigation import MapType, Mode, Path, Waypoint
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .client import NavigationClient
+from .navigation import Navigation
+from .service import NavigationRPCService
+
+__all__ = ["GeoPoint", "GeoGeometry", "NavigationClient", "Navigation", "Waypoint", "Mode", "Path", "MapType"]
+
+Registry.register_api(ResourceRegistration(Navigation, NavigationRPCService, lambda name, channel: NavigationClient(name, channel)))

viam/services/navigation/client.py

@@ -0,0 +1,99 @@
+from typing import List, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.service.navigation import (
+    AddWaypointRequest,
+    GetLocationRequest,
+    GetLocationResponse,
+    GetModeRequest,
+    GetModeResponse,
+    GetObstaclesRequest,
+    GetObstaclesResponse,
+    GetPathsRequest,
+    GetPathsResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    GetWaypointsRequest,
+    GetWaypointsResponse,
+    NavigationServiceStub,
+    Path,
+    RemoveWaypointRequest,
+    SetModeRequest,
+)
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+
+from . import GeoGeometry, GeoPoint, MapType, Mode, Waypoint
+from .navigation import Navigation
+
+
+class NavigationClient(Navigation, ReconfigurableResourceRPCClientBase):
+    """
+    Connect to the NavigationService, which allows the robot to navigate to specified locations.
+    """
+
+    client: NavigationServiceStub
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = NavigationServiceStub(channel)
+        super().__init__(name)
+
+    async def get_paths(self, *, timeout: Optional[float] = None, **kwargs) -> List[Path]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPathsRequest(name=self.name)
+        response: GetPathsResponse = await self.client.GetPaths(request, timeout=timeout, metadata=md)
+        return list(response.paths)
+
+    async def get_location(self, *, timeout: Optional[float] = None, **kwargs) -> GeoPoint:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetLocationRequest(name=self.name)
+        response: GetLocationResponse = await self.client.GetLocation(request, timeout=timeout, metadata=md)
+        return response.location
+
+    async def get_obstacles(self, *, timeout: Optional[float] = None, **kwargs) -> List[GeoGeometry]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetObstaclesRequest(name=self.name)
+        response: GetObstaclesResponse = await self.client.GetObstacles(request, timeout=timeout, metadata=md)
+        return list(response.obstacles)
+
+    async def get_waypoints(self, *, timeout: Optional[float] = None, **kwargs) -> List[Waypoint]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetWaypointsRequest(name=self.name)
+        response: GetWaypointsResponse = await self.client.GetWaypoints(request, timeout=timeout, metadata=md)
+        return list(response.waypoints)
+
+    async def add_waypoint(self, point: GeoPoint, *, timeout: Optional[float] = None, **kwargs):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = AddWaypointRequest(name=self.name, location=point)
+        await self.client.AddWaypoint(request, timeout=timeout, metadata=md)
+
+    async def remove_waypoint(self, id: str, *, timeout: Optional[float] = None, **kwargs):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = RemoveWaypointRequest(name=self.name, id=id)
+        await self.client.RemoveWaypoint(request, timeout=timeout, metadata=md)
+
+    async def get_mode(self, *, timeout: Optional[float] = None, **kwargs) -> Mode.ValueType:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetModeRequest(name=self.name)
+        response: GetModeResponse = await self.client.GetMode(request, timeout=timeout, metadata=md)
+        return response.mode
+
+    async def set_mode(self, mode: Mode.ValueType, *, timeout: Optional[float] = None, **kwargs):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = SetModeRequest(name=self.name, mode=mode)
+        await self.client.SetMode(request, timeout=timeout, metadata=md)
+
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> MapType.ValueType:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPropertiesRequest(name=self.name)
+        response: GetPropertiesResponse = await self.client.GetProperties(request, timeout=timeout, metadata=md)
+        return response.map_type
+
+    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)