viam-sdk 0.25.2__py3-none-linux_armv7l.whl → 0.62.0__py3-none-linux_armv7l.whl

viam/services/mlmodel/service.py

@@ -3,6 +3,7 @@ from grpclib.server import Stream
 from viam.proto.service.mlmodel import InferRequest, InferResponse, MetadataRequest, MetadataResponse, MLModelServiceBase
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.services.mlmodel.utils import flat_tensors_to_ndarrays, ndarrays_to_flat_tensors
+from viam.utils import struct_to_dict
 
 from .mlmodel import MLModel
 
@@ -19,8 +20,9 @@ class MLModelRPCService(MLModelServiceBase, ResourceRPCServiceBase):
         assert request is not None
         name = request.name
         mlmodel = self.get_resource(name)
+        extra = struct_to_dict(request.extra)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        output_tensors = await mlmodel.infer(input_tensors=flat_tensors_to_ndarrays(request.input_tensors), timeout=timeout)
+        output_tensors = await mlmodel.infer(input_tensors=flat_tensors_to_ndarrays(request.input_tensors), extra=extra, timeout=timeout)
         response = InferResponse(output_tensors=ndarrays_to_flat_tensors(output_tensors))
         await stream.send_message(response)
 
@@ -29,7 +31,8 @@ class MLModelRPCService(MLModelServiceBase, ResourceRPCServiceBase):
         assert request is not None
         name = request.name
         mlmodel = self.get_resource(name)
+        extra = struct_to_dict(request.extra)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        metadata = await mlmodel.metadata(timeout=timeout)
+        metadata = await mlmodel.metadata(extra=extra, timeout=timeout)
         response = MetadataResponse(metadata=metadata)
         await stream.send_message(response)

viam/services/mlmodel/utils.py

@@ -2,6 +2,7 @@ from typing import Dict
 
 import numpy as np
 from numpy.typing import NDArray
+from packaging.version import Version
 
 from viam.proto.service.mlmodel import (
     FlatTensor,
@@ -37,7 +38,16 @@ def flat_tensors_to_ndarrays(flat_tensors: FlatTensors) -> Dict[str, NDArray]:
         """Takes flat data (protobuf RepeatedScalarFieldContainer | bytes) to output an ndarray
         of appropriate dtype and shape"""
         make_array = np.frombuffer if dtype == np.int8 or dtype == np.uint8 else np.array
-        return make_array(flat_data, dtype).reshape(shape)
+        # As per proto, int16 and uint16 are stored as uint32. As of numpy v2, this creates
+        # some strange interactions with negative values for int16. Specifically, we end up
+        # trying to create an np.Int16 value with an out of bounds int due to rollover.
+        # Creating our array as a uint32 array initially and then casting to int16 solves this.
+        if Version(np.__version__) >= Version("2") and dtype == np.int16:
+            arr = np.astype(make_array(flat_data, np.uint32), np.int16)  # pyright: ignore [reportAttributeAccessIssue]
+
+        else:
+            arr = make_array(flat_data, dtype)
+        return arr.reshape(shape)
 
     ndarrays: Dict[str, NDArray] = dict()
     for name, flat_tensor in flat_tensors.tensors.items():

viam/services/motion/__init__.py

@@ -5,10 +5,10 @@ from .client import MotionClient
 from .motion import Motion
 from .service import MotionRPCService
 
-__all__ = ["MotionClient", "MotionConfiguration", "Constraints"]
+__all__ = ["Motion", "MotionClient", "MotionConfiguration", "Constraints"]
 
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         Motion,
         MotionRPCService,

viam/services/motion/client.py

@@ -10,7 +10,6 @@ from viam.proto.common import (
     GeoPoint,
     Pose,
     PoseInFrame,
-    ResourceName,
     Transform,
     WorldState,
 )
@@ -54,16 +53,16 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
 
     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:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = MoveRequest(
             name=self.name,
             destination=destination,
@@ -72,14 +71,14 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
             constraints=constraints,
             extra=dict_to_struct(extra),
         )
-        response: MoveResponse = await self.client.Move(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,
+        movement_sensor_name: str,
         obstacles: Optional[Sequence[GeoGeometry]] = None,
         heading: Optional[float] = None,
         configuration: Optional[MotionConfiguration] = None,
@@ -87,9 +86,9 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
         bounding_regions: Optional[Sequence[GeoGeometry]] = None,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> str:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = MoveOnGlobeRequest(
             name=self.name,
             component_name=component_name,
@@ -101,22 +100,22 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
             bounding_regions=bounding_regions,
             extra=dict_to_struct(extra),
         )
-        response: MoveOnGlobeResponse = await self.client.MoveOnGlobe(request, timeout=timeout)
+        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,
+        **kwargs,
     ) -> str:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = MoveOnMapRequest(
             name=self.name,
             destination=destination,
@@ -126,38 +125,38 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
             obstacles=obstacles,
             extra=dict_to_struct(extra),
         )
-        response: MoveOnMapResponse = await self.client.MoveOnMap(request, timeout=timeout)
+        response: MoveOnMapResponse = await self.client.MoveOnMap(request, timeout=timeout, metadata=md)
         return response.execution_id
 
     async def stop_plan(
         self,
-        component_name: ResourceName,
+        component_name: str,
         *,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ):
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
 
         request = StopPlanRequest(
             name=self.name,
             component_name=component_name,
             extra=dict_to_struct(extra),
         )
-        _: StopPlanResponse = await self.client.StopPlan(request, timeout=timeout)
+        _: StopPlanResponse = await self.client.StopPlan(request, timeout=timeout, metadata=md)
         return
 
     async def get_plan(
         self,
-        component_name: ResourceName,
+        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:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
 
         request = GetPlanRequest(
             name=self.name,
@@ -166,7 +165,7 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
             execution_id=execution_id,
             extra=dict_to_struct(extra),
         )
-        response: GetPlanResponse = await self.client.GetPlan(request, timeout=timeout)
+        response: GetPlanResponse = await self.client.GetPlan(request, timeout=timeout, metadata=md)
         return response
 
     async def list_plan_statuses(
@@ -175,29 +174,29 @@ class MotionClient(Motion, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> Sequence[PlanStatusWithID]:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
 
         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)
+        response: ListPlanStatusesResponse = await self.client.ListPlanStatuses(request, timeout=timeout, metadata=md)
         return response.plan_statuses_with_ids
 
     async def get_pose(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination_frame: str,
         supplemental_transforms: Optional[Sequence[Transform]] = None,
         *,
         extra: Optional[Mapping[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> PoseInFrame:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPoseRequest(
             name=self.name,
             component_name=component_name,
@@ -205,10 +204,11 @@ class MotionClient(Motion, 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]:
+    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/motion/motion.py

@@ -7,9 +7,9 @@ if sys.version_info >= (3, 10):
 else:
     from typing_extensions import TypeAlias
 
-from viam.proto.common import GeoGeometry, Geometry, GeoPoint, Pose, PoseInFrame, ResourceName, Transform, WorldState
+from viam.proto.common import GeoGeometry, Geometry, GeoPoint, Pose, PoseInFrame, Transform, WorldState
 from viam.proto.service.motion import Constraints, GetPlanResponse, MotionConfiguration, PlanStatusWithID
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, Subtype
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
 from viam.utils import ValueTypes
 
 from ..service_base import ServiceBase
@@ -21,19 +21,19 @@ class Motion(ServiceBase):
     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/services/motion/>`_.
+    For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/>`_.
     """
 
     Plan: "TypeAlias" = GetPlanResponse
 
-    SUBTYPE: Final = Subtype(  # pyright: ignore [reportIncompatibleVariableOverride]
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
         RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "motion"
     )
 
     @abc.abstractmethod
     async def move(
         self,
-        component_name: ResourceName,
+        component_name: str,
         destination: PoseInFrame,
         world_state: Optional[WorldState] = None,
         constraints: Optional[Constraints] = None,
@@ -44,18 +44,17 @@ class Motion(ServiceBase):
         """Plan and execute a movement to move the component specified to its goal destination.
 
         Note: Frames designated with respect to components can also be used as the ``component_name`` when calling for a move. This
-        technique allows for planning and moving the frame itself to the ``destination``. To do so, simply create a resource name with
-        originating ReferenceFrame's name. Then pass in the resource name into ``component_name``. Ex::
+        technique allows for planning and moving the frame itself to the ``destination``.
+        To do so, simply pass in a string into ``component_name``. Ex::
 
-            resource_name = Arm.get_resource_name("externalFrame")
-            success = await MotionServiceClient.move(resource_name, ...)
+            success = await MotionServiceClient.move("externalFrame", ...)
 
         ::
 
-            motion = MotionClient.from_robot(robot=robot, name="builtin")
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Assumes a gripper configured with name "my_gripper" on the machine
-            gripper_name = Gripper.get_resource_name("my_gripper")
+            # Assumes "my_gripper" on the machine
+            gripper_name = "my_gripper"
             my_frame = "my_gripper_offset"
 
             goal_pose = Pose(x=0, y=0, z=300, o_x=0, o_y=0, o_z=1, theta=0)
@@ -69,27 +68,35 @@ class Motion(ServiceBase):
                                   extra={})
 
         Args:
-            component_name (viam.proto.common.ResourceName): Name of a component on a given robot.
+            component_name (str): Name of a component on a given robot.
             destination (viam.proto.common.PoseInFrame): The destination to move to, expressed as a ``Pose`` and the frame in which it was
                 observed.
             world_state (viam.proto.common.WorldState): When supplied, the motion service will create a plan that obeys any constraints
                 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.
+                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/services/motion/>`_.
+        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: ResourceName,
+        component_name: str,
         destination: GeoPoint,
-        movement_sensor_name: ResourceName,
+        movement_sensor_name: str,
         obstacles: Optional[Sequence[GeoGeometry]] = None,
         heading: Optional[float] = None,
         configuration: Optional[MotionConfiguration] = None,
@@ -110,26 +117,25 @@ class Motion(ServiceBase):
 
         ::
 
-            motion = MotionClient.from_robot(robot=robot, name="builtin")
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Get the ResourceNames of the base and movement sensor
-            my_base_resource_name = Base.get_resource_name("my_base")
-            mvmnt_sensor_resource_name = MovementSensor.get_resource_name(
-                "my_movement_sensor")
+            # Get the names of the base and movement sensor
+            my_base_name = "my_base"
+            mvmnt_sensor_name = "my_movement_sensor"
             #  Define a destination GeoPoint at the GPS coordinates [0, 0]
             my_destination = movement_sensor.GeoPoint(latitude=0, longitude=0)
 
             # Move the base component to the designated geographic location, as reported by the movement sensor
             execution_id = await motion.move_on_globe(
-                component_name=my_base_resource_name,
+                component_name=my_base_name,
                 destination=my_destination,
-                movement_sensor_name=mvmnt_sensor_resource_name)
+                movement_sensor_name=mvmnt_sensor_name)
 
         Args:
-            component_name (ResourceName): The ResourceName of the base to move.
+            component_name (str): The name of the base to move.
             destination (GeoPoint): The location of the component's destination, represented in geographic notation as a
                 GeoPoint (lat, lng).
-            movement_sensor_name (ResourceName): The ResourceName of the movement sensor that you want to use to check
+            movement_sensor_name (str): The name of the movement sensor that you want to use to check
                 the machine's location.
             obstacles (Optional[Sequence[GeoGeometry]]): Obstacles to consider when planning the motion of the component,
                 with each represented as a GeoGeometry. Default: None
@@ -155,16 +161,16 @@ class Motion(ServiceBase):
         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/services/motion/>`_.
+        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: ResourceName,
+        component_name: str,
         destination: Pose,
-        slam_service_name: ResourceName,
+        slam_service_name: str,
         configuration: Optional[MotionConfiguration] = None,
         obstacles: Optional[Sequence[Geometry]] = None,
         *,
@@ -184,25 +190,25 @@ class Motion(ServiceBase):
 
         ::
 
-            motion = MotionClient.from_robot(robot=robot, name="builtin")
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
 
-            # Get the ResourceNames of the base component and SLAM service
-            my_base_resource_name = Base.get_resource_name("my_base")
-            my_slam_service_name = SLAMClient.get_resource_name("my_slam_service")
+            # Get the names of the base component and SLAM service
+            my_base_name = "my_base"
+            my_slam_service_name = "my_slam_service"
 
             # Define a destination pose with respect to the origin of the map from the SLAM service "my_slam_service"
             my_pose = Pose(y=10)
 
             # Move the base component to the destination pose of Y=10, a location of
             # (0, 10, 0) in respect to the origin of the map
-            execution_id = await motion.move_on_map(component_name=my_base_resource_name,
+            execution_id = await motion.move_on_map(component_name=my_base_name,
                                                     destination=my_pose,
                                                     slam_service_name=my_slam_service_name)
 
         Args:
-            component_name (ResourceName): The ResourceName of the base to move.
+            component_name (str): The name of the base to move.
             destination (Pose): The destination, which can be any Pose with respect to the SLAM map's origin.
-            slam_service_name (ResourceName): The ResourceName of the SLAM service from which the SLAM map is requested.
+            slam_service_name (str): The name of the SLAM service from which the SLAM map is requested.
             configuration (Optional[MotionConfiguration]): The configuration you want to set across this machine for this motion service.
                 This parameter and each of its fields are optional.
 
@@ -222,14 +228,14 @@ class Motion(ServiceBase):
         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/services/motion/>`_.
+        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: ResourceName,
+        component_name: str,
         *,
         extra: Optional[Mapping[str, ValueTypes]] = None,
         timeout: Optional[float] = None,
@@ -238,23 +244,25 @@ class Motion(ServiceBase):
 
         ::
 
+            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_resource_name = Base.get_resource_name("my_base")
+            my_base_name = "my_base"
             await motion.stop_plan(component_name=mvmnt_sensor)
 
         Args:
-            component_name (ResourceName): The component to stop
+            component_name (str): The component to stop
 
-        For more information, see `Motion service <https://docs.viam.com/services/motion/>`_.
+        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: ResourceName,
+        component_name: str,
         last_plan_only: bool = False,
         execution_id: Optional[str] = None,
         *,
@@ -280,20 +288,20 @@ class Motion(ServiceBase):
 
         ::
 
-            motion = MotionClient.from_robot(robot=robot, name="builtin")
-            my_base_resource_name = Base.get_resource_name("my_base")
+            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_resource_name)
+            resp = await motion.get_plan(component_name=my_base_name)
 
         Args:
-            component_name (ResourceName): The component to stop
+            component_name (str): The component to stop
             last_plan_only (Optional[bool]): If supplied, the response will only return the last plan for the component / execution.
             execution_id (Optional[str]): If supplied, the response will only return plans with the provided execution_id.
 
         Returns:
             ``GetPlanResponse`` (GetPlanResponse): The current PlanWithStatus & replan history which matches the request
 
-        For more information, see `Motion service <https://docs.viam.com/services/motion/>`_.
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#getplan>`_.
         """
         ...
 
@@ -315,7 +323,7 @@ class Motion(ServiceBase):
 
         ::
 
-            motion = MotionClient.from_robot(robot=robot, name="builtin")
+            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()
 
@@ -326,14 +334,14 @@ class Motion(ServiceBase):
             ``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/services/motion/>`_.
+        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: ResourceName,
+        component_name: str,
         destination_frame: str,
         supplemental_transforms: Optional[Sequence[Transform]] = None,
         *,
@@ -345,25 +353,21 @@ class Motion(ServiceBase):
 
         ::
 
-            # Note that the example uses the ``Arm`` class, but any component class that inherits from ``ComponentBase`` will work
-            # (``Base``, ``Gripper``, etc).
-
-            # Create a `component_name`:
-            component_name = Arm.get_resource_name("arm")
+            # 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.
-            robot = await connect()
+            machine = await connect()
 
-            motion = MotionClient.from_robot(robot=robot, name="builtin")
-            gripperName = Gripper.get_resource_name("my_gripper")
-            gripperPoseInWorld = await motion.get_pose(component_name=gripperName,
-                                                    destination_frame="world")
+            motion = MotionClient.from_robot(robot=machine, name="builtin")
+            gripperPoseInWorld = await motion.get_pose(component_name="my_gripper",
+                                                       destination_frame="world")
 
         Args:
-            component_name (viam.proto.common.ResourceName): Name of a component on a robot.
+            component_name (str): Name of a component on a robot.
             destination_frame (str): Name of the desired reference frame.
             supplemental_transforms (Optional[List[viam.proto.common.Transform]]): Transforms used to augment the robot's frame while
                 calculating pose.
@@ -371,6 +375,6 @@ class Motion(ServiceBase):
         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/services/motion/>`_.
+        For more information, see `Motion service <https://docs.viam.com/dev/reference/apis/services/motion/#getpose>`_.
         """
         ...

viam/services/navigation/__init__.py

@@ -8,4 +8,4 @@ from .service import NavigationRPCService
 
 __all__ = ["GeoPoint", "GeoGeometry", "NavigationClient", "Navigation", "Waypoint", "Mode", "Path", "MapType"]
 
-Registry.register_subtype(ResourceRegistration(Navigation, NavigationRPCService, lambda name, channel: NavigationClient(name, channel)))
+Registry.register_api(ResourceRegistration(Navigation, NavigationRPCService, lambda name, channel: NavigationClient(name, channel)))