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

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): A waypoint 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)

viam/services/service_base.py

@@ -1,13 +1,15 @@
 import abc
+from logging import Logger
 from typing import TYPE_CHECKING, ClassVar, Mapping, Optional, cast
 
 from typing_extensions import Self
 
+from viam.logging import getLogger
 from viam.resource.base import ResourceBase
 from viam.utils import ValueTypes
 
 if TYPE_CHECKING:
-    from viam.resource.types import Subtype
+    from viam.resource.types import API
     from viam.robot.client import RobotClient
 
 
@@ -16,15 +18,32 @@ class ServiceBase(abc.ABC, ResourceBase):
     All services must inherit from this class.
     """
 
-    SUBTYPE: ClassVar["Subtype"]
+    API: ClassVar["API"]
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, *, logger: Optional[Logger] = None) -> None:
         self.name = name
+        self.logger = logger if logger is not None else getLogger(f"{self.API}.{name}")
 
     @classmethod
     def from_robot(cls, robot: "RobotClient", name: str) -> Self:
         """Get the service named ``name`` from the provided robot.
 
+        ::
+
+            async def connect() -> RobotClient:
+                # Replace "<API-KEY>" (including brackets) with your API key and "<API-KEY-ID>" with your API key ID
+                options = RobotClient.Options.with_api_key("<API-KEY>", "<API-KEY-ID>")
+                # Replace "<MACHINE-URL>" (included brackets) with your machine's connection URL or FQDN
+                return await RobotClient.at_address("<MACHINE-URL>", options)
+
+            async def main():
+                robot = await connect()
+
+                # Can be used with any resource, using the motion service as an example
+                motion = MotionClient.from_robot(robot=machine, name="builtin")
+
+                robot.close()
+
         Args:
             robot (RobotClient): The robot
             name (str): The name of the service
@@ -33,7 +52,27 @@ class ServiceBase(abc.ABC, ResourceBase):
             Self: The service, if it exists on the robot
         """
         service = robot.get_service(cls.get_resource_name(name))
-        return cast(cls, service)
+        return cast(cls, service)  # type: ignore
 
     async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes]:
+        """Send/receive arbitrary commands.
+
+        ::
+
+            service = SERVICE.from_robot(robot=machine, "builtin")  # replace SERVICE with the appropriate class
+
+            my_command = {
+              "cmnd": "dosomething",
+              "someparameter": 52
+            }
+
+            # Can be used with any resource, using the motion service as an example
+            await service.do_command(command=my_command)
+
+        Args:
+            command (Dict[str, ValueTypes]): The command to execute
+
+        Returns:
+            Dict[str, ValueTypes]: Result of the executed command
+        """
         raise NotImplementedError()

viam/services/service_client_base.py

@@ -6,7 +6,7 @@ from typing_extensions import Self
 
 from viam.errors import ResourceNotFoundError
 from viam.proto.common import ResourceName
-from viam.resource.base import ResourceBase, Subtype
+from viam.resource.base import API, ResourceBase
 from viam.utils import ValueTypes
 
 if TYPE_CHECKING:
@@ -19,7 +19,7 @@ class ServiceClientBase(abc.ABC, ResourceBase):
     All service clients must inherit from this class.
     """
 
-    SUBTYPE: ClassVar[Subtype]
+    API: ClassVar[API]
     channel: Channel
 
     def __init__(self, name: str, channel: Channel):
@@ -37,10 +37,10 @@ class ServiceClientBase(abc.ABC, ResourceBase):
         Returns:
             Self: The service client, if it exists on the robot
         """
-        resource_name = ResourceName(namespace="rdk", type="service", subtype=cls.SUBTYPE.resource_subtype, name=name)
+        resource_name = ResourceName(namespace="rdk", type="service", subtype=cls.API.resource_subtype, name=name)
         if resource_name not in robot.resource_names:
             raise ResourceNotFoundError(resource_name.subtype, resource_name.name)
         return cls(name, robot._channel)
 
-    def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes]:
+    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes]:
         raise NotImplementedError()

viam/services/slam/__init__.py

@@ -1,4 +1,5 @@
 from viam.proto.common import Pose
+from viam.proto.service.slam import MappingMode, SensorInfo
 from viam.resource.registry import Registry, ResourceRegistration
 
 from .client import SLAMClient
@@ -7,8 +8,10 @@ from .slam import SLAM
 
 __all__ = [
     "Pose",
+    "MappingMode",
+    "SensorInfo",
     "SLAMClient",
     "SLAM",
 ]
 
-Registry.register_subtype(ResourceRegistration(SLAM, SLAMRPCService, lambda name, channel: SLAMClient(name, channel)))
+Registry.register_api(ResourceRegistration(SLAM, SLAMRPCService, lambda name, channel: SLAMClient(name, channel)))

viam/services/slam/client.py

@@ -10,6 +10,7 @@ from viam.proto.service.slam import (
     GetPointCloudMapResponse,
     GetPositionRequest,
     GetPositionResponse,
+    GetPropertiesRequest,
     SLAMServiceStub,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
@@ -31,22 +32,31 @@ class SLAMClient(SLAM, ReconfigurableResourceRPCClientBase):
         self.client = SLAMServiceStub(channel)
         super().__init__(name)
 
-    async def get_position(self, *, timeout: Optional[float] = None) -> Pose:
+    async def get_position(self, *, timeout: Optional[float] = None, **kwargs) -> Pose:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPositionRequest(name=self.name)
-        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout)
+        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout, metadata=md)
         return response.pose
 
-    async def get_point_cloud_map(self, *, timeout: Optional[float] = None) -> List[GetPointCloudMapResponse]:
-        request = GetPointCloudMapRequest(name=self.name)
-        response: List[GetPointCloudMapResponse] = await self.client.GetPointCloudMap(request, timeout=timeout)
-        return response
+    async def get_point_cloud_map(self, return_edited_map: bool = False, *, timeout: Optional[float] = None, **kwargs) -> List[bytes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPointCloudMapRequest(name=self.name, return_edited_map=return_edited_map)
+        response: List[GetPointCloudMapResponse] = await self.client.GetPointCloudMap(request, timeout=timeout, metadata=md)
+        return [r.point_cloud_pcd_chunk for r in response]
 
-    async def get_internal_state(self, *, timeout: Optional[float] = None) -> List[GetInternalStateResponse]:
+    async def get_internal_state(self, *, timeout: Optional[float] = None, **kwargs) -> List[bytes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetInternalStateRequest(name=self.name)
-        response: List[GetInternalStateResponse] = await self.client.GetInternalState(request, timeout=timeout)
-        return response
+        response: List[GetInternalStateResponse] = await self.client.GetInternalState(request, timeout=timeout, metadata=md)
+        return [r.internal_state_chunk for r in response]
 
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None) -> Mapping[str, ValueTypes]:
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> SLAM.Properties:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetPropertiesRequest(name=self.name)
+        return await self.client.GetProperties(request, timeout=timeout, metadata=md)
+
+    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)

viam/services/slam/service.py

@@ -1,6 +1,5 @@
 from grpclib.server import Stream
 
-from viam.errors import ResourceNotFoundError
 from viam.proto.common import DoCommandRequest, DoCommandResponse
 from viam.proto.service.slam import (
     GetInternalStateRequest,
@@ -9,6 +8,8 @@ from viam.proto.service.slam import (
     GetPointCloudMapResponse,
     GetPositionRequest,
     GetPositionResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
     SLAMServiceBase,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
@@ -17,7 +18,7 @@ from viam.utils import dict_to_struct, struct_to_dict
 from .slam import SLAM
 
 
-class SLAMRPCService(SLAMServiceBase, ResourceRPCServiceBase[SLAM]):
+class SLAMRPCService(SLAMServiceBase, ResourceRPCServiceBase):
     """
     gRPC Service for a SLAM service
     """
@@ -28,10 +29,7 @@ class SLAMRPCService(SLAMServiceBase, ResourceRPCServiceBase[SLAM]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            slam = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        slam = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         chunks = await slam.get_internal_state(timeout=timeout)
         for chunk in chunks:
@@ -42,12 +40,9 @@ class SLAMRPCService(SLAMServiceBase, ResourceRPCServiceBase[SLAM]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            slam = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        slam = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        chunks = await slam.get_point_cloud_map(timeout=timeout)
+        chunks = await slam.get_point_cloud_map(return_edited_map=request.return_edited_map, timeout=timeout)
         for chunk in chunks:
             response = GetPointCloudMapResponse(point_cloud_pcd_chunk=chunk)
             await stream.send_message(response)
@@ -56,22 +51,24 @@ class SLAMRPCService(SLAMServiceBase, ResourceRPCServiceBase[SLAM]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            slam = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        slam = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         position = await slam.get_position(timeout=timeout)
         response = GetPositionResponse(pose=position)
         await stream.send_message(response)
 
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        slam = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await slam.get_properties(timeout=timeout)
+        await stream.send_message(properties)
+
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            slam = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        slam = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await slam.do_command(command=struct_to_dict(request.command), timeout=timeout, metadata=stream.metadata)
         response = DoCommandResponse(result=dict_to_struct(result))