viam-sdk 0.45.2__py3-none-win_amd64.whl

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)

viam/services/navigation/navigation.py

@@ -0,0 +1,250 @@
+import abc
+from typing import Final, List, Optional
+
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
+
+from ..service_base import ServiceBase
+from . import GeoGeometry, GeoPoint, MapType, Mode, Path, Waypoint
+
+
+class Navigation(ServiceBase):
+    """
+    Navigation represents a Navigation service.
+
+    This acts as an abstract base class for any drivers representing specific
+    navigation service implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+
+    For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "navigation"
+    )
+
+    @abc.abstractmethod
+    async def get_paths(self, *, timeout: Optional[float]) -> List[Path]:
+        """
+        Get each path, the series of geo points the robot plans to travel through
+        to get to a destination waypoint, in the machine's motion planning.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Get a list containing each path stored by the navigation service
+            paths = await my_nav.get_paths()
+
+        Args:
+            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:
+            List[navigation.Path]: An array comprised of Paths, where each path is either a user-provided destination or
+            a Waypoint, along with the corresponding set of geopoints. This outlines the route the machine is expected to take to
+            reach the specified destination or Waypoint.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#getpaths>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_location(self, *, timeout: Optional[float]) -> GeoPoint:
+        """
+        Get the current location of the robot in the navigation service.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Get the current location of the robot in the navigation service
+            location = await my_nav.get_location()
+
+        Args:
+            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:
+            navigation.GeoPoint: The current location of the robot in the navigation service,
+            represented in a GeoPoint with latitude and longitude values.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#getlocation>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_obstacles(self, *, timeout: Optional[float]) -> List[GeoGeometry]:
+        """
+        Get an array or list of the obstacles currently in the service's data storage.
+        These are objects designated for the robot to avoid when navigating.
+        These include all transient obstacles which are discovered by the vision services configured for the navigation service,
+        in addition to the obstacles that are configured as a part of the service.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Get a list containing each obstacle stored by the navigation service
+            obstacles = await my_nav.get_obstacles()
+
+        Args:
+            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:
+            List[navigation.GeoGeometry]: A list comprised of each GeoGeometry in the service's data storage.
+            These are objects designated for the robot to avoid when navigating.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#getobstacles>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_waypoints(self, *, timeout: Optional[float]) -> List[Waypoint]:
+        """
+        Get an array of waypoints currently in the service's data storage.
+        These are locations designated within a path for the robot to navigate to.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Get a list containing each waypoint stored by the navigation service
+            waypoints = await my_nav.get_waypoints()
+
+        Args:
+            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:
+            List[navigation.Waypoint]: An array comprised of each Waypoint in the service's data storage.
+            These are locations designated within a path for the robot to navigate to.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#getwaypoints>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def add_waypoint(self, point: GeoPoint, *, timeout: Optional[float]):
+        """
+        Add a waypoint to the service's data storage.
+
+        ::
+
+           my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Create a new waypoint with latitude and longitude values of 0 degrees
+            location = GeoPoint(latitude=0, longitude=0)
+
+
+            # Add your waypoint to the service's data storage
+            await my_nav.add_waypoint(point=location)
+
+        Args:
+            point (navigation.GeoPoint): The current location of the robot in the navigation service,
+                represented in a GeoPoint with latitude and longitude values.
+            timeout (Optional[float]): An option to set how long to wait (in seconds)
+                before calling a time-out and closing the underlying RPC call.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#addwaypoint>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def remove_waypoint(self, id: str, *, timeout: Optional[float]):
+        """
+        Remove a waypoint from the service's data storage. If the robot is currently navigating to this waypoint,
+        the motion will be canceled, and the robot will proceed to the next waypoint.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Remove the waypoint matching that ObjectID from the service's data storage
+            await my_nav.remove_waypoint(waypoint_id)
+
+        Args:
+            id (str): The MongoDB ObjectID of the Waypoint to remove from the service's data storage.
+            timeout (Optional[float]): An option to set how long to wait (in seconds)
+                before calling a time-out and closing the underlying RPC call.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#removewaypoint>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_mode(self, *, timeout: Optional[float]) -> Mode.ValueType:
+        """
+        Get the Mode the service is operating in.
+
+        There are two options for modes: MODE_MANUAL or MODE_WAYPOINT.
+
+            MODE_WAYPOINT: Start to look for added waypoints and begin autonomous navigation.
+            MODE_MANUAL: Stop autonomous navigation between waypoints and allow the base to be controlled manually.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Get the Mode the service is operating in
+            await my_nav.get_mode()
+
+        Args:
+            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:
+            navigation.Mode.ValueType: The Mode the service is operating in.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#getmode>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def set_mode(self, mode: Mode.ValueType, *, timeout: Optional[float]):
+        """
+        Set the Mode the service is operating in.
+
+        There are two options for modes: MODE_MANUAL or MODE_WAYPOINT.
+
+            MODE_WAYPOINT: Start to look for added waypoints and begin autonomous navigation.
+            MODE_MANUAL: Stop autonomous navigation between waypoints and allow the base to be controlled manually.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Set the Mode the service is operating in to MODE_WAYPOINT and begin navigation
+            await my_nav.set_mode(Mode.ValueType.MODE_WAYPOINT)
+
+        Args:
+            timeout (Optional[float]): An option to set how long to wait (in seconds)
+                before calling a time-out and closing the underlying RPC call.
+            mode (navigation.Mode.ValueType): The Mode for the service to operate in.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#setmode>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_properties(self, *, timeout: Optional[float]) -> MapType.ValueType:
+        """
+        Get information about the navigation service.
+
+        ::
+
+            my_nav = NavigationClient.from_robot(robot=machine, name="my_nav_service")
+
+            # Get the properties of the current navigation service.
+            nav_properties = await my_nav.get_properties()
+
+        Args:
+            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:
+            MapType.ValueType: Information about the type of map the service is using.
+
+        For more information, see `Navigation service <https://docs.viam.com/dev/reference/apis/services/navigation/#getproperties>`_.
+        """
+        ...

viam/services/navigation/service.py

@@ -0,0 +1,137 @@
+from grpclib.server import Stream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.service.navigation import (
+    AddWaypointRequest,
+    AddWaypointResponse,
+    GetLocationRequest,
+    GetLocationResponse,
+    GetModeRequest,
+    GetModeResponse,
+    GetObstaclesRequest,
+    GetObstaclesResponse,
+    GetPathsRequest,
+    GetPathsResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    GetWaypointsRequest,
+    GetWaypointsResponse,
+    NavigationServiceBase,
+    RemoveWaypointRequest,
+    RemoveWaypointResponse,
+    SetModeRequest,
+    SetModeResponse,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .navigation import Navigation
+
+
+class NavigationRPCService(NavigationServiceBase, ResourceRPCServiceBase):
+    """
+    gRPC Service for a Navigation service
+    """
+
+    RESOURCE_TYPE = Navigation
+
+    async def GetPaths(self, stream: Stream[GetPathsRequest, GetPathsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        paths = await navigation.get_paths(timeout=timeout)
+        response = GetPathsResponse(paths=paths)
+        await stream.send_message(response)
+
+    async def GetLocation(self, stream: Stream[GetLocationRequest, GetLocationResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        location = await navigation.get_location(timeout=timeout)
+        response = GetLocationResponse(location=location)
+        await stream.send_message(response)
+
+    async def GetObstacles(self, stream: Stream[GetObstaclesRequest, GetObstaclesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        obstacles = await navigation.get_obstacles(timeout=timeout)
+        response = GetObstaclesResponse(obstacles=obstacles)
+        await stream.send_message(response)
+
+    async def GetWaypoints(self, stream: Stream[GetWaypointsRequest, GetWaypointsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        waypoints = await navigation.get_waypoints(timeout=timeout)
+        response = GetWaypointsResponse(waypoints=waypoints)
+        await stream.send_message(response)
+
+    async def AddWaypoint(self, stream: Stream[AddWaypointRequest, AddWaypointResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        point = request.location
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await navigation.add_waypoint(point, timeout=timeout)
+        response = AddWaypointResponse()
+        await stream.send_message(response)
+
+    async def RemoveWaypoint(self, stream: Stream[RemoveWaypointRequest, RemoveWaypointResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        id = request.id
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await navigation.remove_waypoint(id=id, timeout=timeout)
+        response = RemoveWaypointResponse()
+        await stream.send_message(response)
+
+    async def GetMode(self, stream: Stream[GetModeRequest, GetModeResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        mode = await navigation.get_mode(timeout=timeout)
+        response = GetModeResponse(mode=mode)
+        await stream.send_message(response)
+
+    async def SetMode(self, stream: Stream[SetModeRequest, SetModeResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        mode = request.mode
+        navigation = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await navigation.set_mode(mode, timeout=timeout)
+        response = SetModeResponse()
+        await stream.send_message(response)
+
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        navigation = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        map_type = await navigation.get_properties(timeout=timeout)
+        response = GetPropertiesResponse(map_type=map_type)
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        navigation = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await navigation.do_command(command=struct_to_dict(request.command), timeout=timeout, metadata=stream.metadata)
+        response = DoCommandResponse(result=dict_to_struct(result))
+        await stream.send_message(response)