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

viam/components/encoder/encoder.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import Any, Dict, Final, Optional, Tuple
 
 from viam.proto.component.encoder import PositionType
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
 
 from ..component_base import ComponentBase
 
@@ -20,9 +20,17 @@ class Encoder(ComponentBase):
     This acts as an abstract base class for any drivers representing specific
     encoder implementations. This cannot be used on its own. If the ``__init__()`` function is
     overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.encoder import Encoder
+
+    For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "encoder")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "encoder"
+    )
 
     @abc.abstractmethod
     async def reset_position(
@@ -34,6 +42,16 @@ class Encoder(ComponentBase):
     ):
         """
         Set the current position to be the new zero (home) position.
+
+        ::
+
+            my_encoder = Encoder.from_robot(robot=machine, name='my_encoder')
+
+            # Reset the zero position of the encoder.
+            await my_encoder.reset_position()
+
+
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#resetposition>`_.
         """
         ...
 
@@ -50,15 +68,27 @@ class Encoder(ComponentBase):
         Report the position of the encoder.
         The value returned is the current position in terms of it's ``position_type``.
         The position will be either in relative units (ticks away from a zero position) for
-        ``PositionType.TICKS`` or absolute units (degrees along a circle) for ``PositionType.DEGREES``.
+        ``PositionType.POSITION_TYPE_TICKS_COUNT`` or absolute units (degrees along a circle)
+        for ``PositionType.POSITION_TYPE_ANGLE_DEGREES``.
+
+        ::
+
+            my_encoder = Encoder.from_robot(robot=machine, name='my_encoder')
+
+            # Get the position of the encoder in ticks
+            position = await my_encoder.get_position(PositionType.POSITION_TYPE_TICKS_COUNT)
+            print("The encoder position is currently ", position[0], position[1])
 
         Args:
-            position_type (PositionType.ValueType): The desired output type of the position
+            position_type (PositionType): The desired output type of the position.
 
         Returns:
-            float: Position of the encoder which can either be ticks since last zeroing
-                   for a relative encoder or degrees for an absolute encoder.
-            PositionType: The type of position the encoder returns (ticks or degrees)
+            Tuple[float, PositionType]:
+            A tuple containing two values; the first [0] the position of the encoder which can either be
+            ticks since last zeroing for a relative encoder or degrees for an absolute encoder, and the second [1] the type of
+            position the encoder returns (ticks or degrees).
+
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#getposition>`_.
         """
         ...
 
@@ -71,10 +101,18 @@ class Encoder(ComponentBase):
         **kwargs,
     ) -> Properties:
         """
-        Report a dictionary mapping optional properties to
-        whether it is supported by this encoder.
+        Return a dictionary of the types of position reporting this encoder supports.
+
+        ::
+
+            my_encoder = Encoder.from_robot(robot=machine, name='my_encoder')
+
+            # Get whether the encoder returns position in ticks or degrees.
+            properties = await my_encoder.get_properties()
 
         Returns:
-            Properties: Map of position types to supported status.
+            Encoder.Properties: Map of position types to supported status.
+
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#getproperties>`_.
         """
         ...

viam/components/encoder/service.py

@@ -1,7 +1,6 @@
 from grpclib.server import Stream
 
-from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
 from viam.proto.component.encoder import (
     EncoderServiceBase,
     GetPositionRequest,
@@ -28,10 +27,7 @@ class EncoderRPCService(EncoderServiceBase, ResourceRPCServiceBase[Encoder]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            encoder = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        encoder = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await encoder.reset_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         await stream.send_message(ResetPositionResponse())
@@ -40,10 +36,7 @@ class EncoderRPCService(EncoderServiceBase, ResourceRPCServiceBase[Encoder]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            encoder = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        encoder = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         position, pos_type = await encoder.get_position(
             position_type=request.position_type, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
@@ -54,10 +47,7 @@ class EncoderRPCService(EncoderServiceBase, ResourceRPCServiceBase[Encoder]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            encoder = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        encoder = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         properties = await encoder.get_properties(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetPropertiesResponse(**properties.__dict__)
@@ -66,11 +56,17 @@ class EncoderRPCService(EncoderServiceBase, ResourceRPCServiceBase[Encoder]):
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            encoder = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        encoder = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await encoder.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)
+
+    async def GetGeometries(self, stream: Stream[GetGeometriesRequest, GetGeometriesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        arm = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await arm.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/gantry/__init__.py

@@ -1,9 +1,4 @@
-import asyncio
-
-from viam.proto.component.gantry import Status as GantryStatus
-from viam.proto.robot import Status
 from viam.resource.registry import Registry, ResourceRegistration
-from viam.utils import message_to_struct
 
 from .client import GantryClient
 from .gantry import Gantry
@@ -13,11 +8,4 @@ __all__ = [
     "Gantry",
 ]
 
-
-async def create_status(component: Gantry) -> Status:
-    (positions_mm, lengths_mm, is_moving) = await asyncio.gather(component.get_position(), component.get_lengths(), component.is_moving())
-    s = GantryStatus(positions_mm=positions_mm, lengths_mm=lengths_mm, is_moving=is_moving)
-    return Status(name=Gantry.get_resource_name(component.name), status=message_to_struct(s))
-
-
-Registry.register_subtype(ResourceRegistration(Gantry, GantryRPCService, lambda name, channel: GantryClient(name, channel), create_status))
+Registry.register_api(ResourceRegistration(Gantry, GantryRPCService, lambda name, channel: GantryClient(name, channel)))

viam/components/gantry/client.py

@@ -1,21 +1,30 @@
-from typing import Any, Dict, List, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional, Tuple
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    Geometry,
+    GetKinematicsRequest,
+    GetKinematicsResponse,
+    KinematicsFileFormat,
+)
 from viam.proto.component.gantry import (
     GantryServiceStub,
     GetLengthsRequest,
     GetLengthsResponse,
     GetPositionRequest,
     GetPositionResponse,
+    HomeRequest,
+    HomeResponse,
     IsMovingRequest,
     IsMovingResponse,
     MoveToPositionRequest,
     StopRequest,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
 from .gantry import Gantry
 
@@ -30,46 +39,92 @@ class GantryClient(Gantry, ReconfigurableResourceRPCClientBase):
         self.client = GantryServiceStub(channel)
         super().__init__(name)
 
-    async def get_position(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[float]:
-        if extra is None:
-            extra = {}
+    async def get_position(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> List[float]:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPositionRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout)
+        response: GetPositionResponse = await self.client.GetPosition(request, timeout=timeout, metadata=md)
         return list(response.positions_mm)
 
     async def move_to_position(
         self,
         positions: List[float],
+        speeds: List[float],
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ):
-        if extra is None:
-            extra = {}
-        request = MoveToPositionRequest(name=self.name, positions_mm=positions, extra=dict_to_struct(extra))
-        await self.client.MoveToPosition(request, timeout=timeout)
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = MoveToPositionRequest(name=self.name, positions_mm=positions, speeds_mm_per_sec=speeds, extra=dict_to_struct(extra))
+        await self.client.MoveToPosition(request, timeout=timeout, metadata=md)
+
+    async def home(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> bool:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = HomeRequest(name=self.name, extra=dict_to_struct(extra))
+        response: HomeResponse = await self.client.Home(request, timeout=timeout, metadata=md)
+        return response.homed
 
-    async def get_lengths(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[float]:
-        if extra is None:
-            extra = {}
+    async def get_lengths(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> List[float]:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetLengthsRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetLengthsResponse = await self.client.GetLengths(request, timeout=timeout)
+        response: GetLengthsResponse = await self.client.GetLengths(request, timeout=timeout, metadata=md)
         return list(response.lengths_mm)
 
-    async def stop(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def stop(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = StopRequest(name=self.name, extra=dict_to_struct(extra))
-        await self.client.Stop(request, timeout=timeout)
+        await self.client.Stop(request, timeout=timeout, metadata=md)
 
-    async def is_moving(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> bool:
-        if extra is None:
-            extra = {}
+    async def is_moving(self, *, timeout: Optional[float] = None, **kwargs) -> bool:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = IsMovingRequest(name=self.name)
-        response: IsMovingResponse = await self.client.IsMoving(request, timeout=timeout)
+        response: IsMovingResponse = await self.client.IsMoving(request, timeout=timeout, metadata=md)
         return response.is_moving
 
-    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)
+
+    async def get_kinematics(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetKinematicsRequest(name=self.name, extra=dict_to_struct(extra))
+        response: GetKinematicsResponse = await self.client.GetKinematics(request, timeout=timeout, metadata=md)
+        return (response.format, response.kinematics_data)
+
+    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[Geometry]:
+        md = kwargs.get("metadata", self.Metadata())
+        return await get_geometries(self.client, self.name, extra, timeout, md)

viam/components/gantry/gantry.py

@@ -1,7 +1,8 @@
 import abc
-from typing import Any, Dict, Final, List, Optional
+from typing import Any, Dict, Final, List, Optional, Tuple
 
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+from viam.components.arm import KinematicsFileFormat
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
 
 from ..component_base import ComponentBase
 
@@ -13,17 +14,34 @@ class Gantry(ComponentBase):
     This acts as an abstract base class for any drivers representing specific
     gantry implementations. This cannot be used on its own. If the ``__init__()`` function is
     overridden, it must call the ``super().__init__()`` function.
+
+    ::
+
+        from viam.components.gantry import Gantry
+
+    For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "gantry")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "gantry"
+    )
 
     @abc.abstractmethod
     async def get_position(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[float]:
         """
-        Get the position in millimeters.
+        Get the positions of the axes of the gantry in millimeters.
+
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            # Get the current positions of the axes of the gantry in millimeters.
+            positions = await my_gantry.get_position()
 
         Returns:
-            List[float]: The position of the axes.
+            List[float]: A list of the position of the axes of the gantry in millimeters.
+
+        For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/#getposition>`_.
         """
         ...
 
@@ -31,27 +49,70 @@ class Gantry(ComponentBase):
     async def move_to_position(
         self,
         positions: List[float],
+        speeds: List[float],
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
         **kwargs,
     ):
         """
-        Move the gantry to a new position.
+        Move the axes of the gantry to the desired positions (mm) at the requested speeds (mm/sec).
+
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            # Create a list of positions for the axes of the gantry to move to. Assume in
+            # this example that the gantry is multi-axis, with 3 axes.
+            examplePositions = [1, 2, 3]
+
+            exampleSpeeds = [3, 9, 12]
+
+            # Move the axes of the gantry to the positions specified.
+            await my_gantry.move_to_position(
+                positions=examplePositions, speeds=exampleSpeeds)
 
         Args:
-            positions (List[float]): List of positions for the axes to move to,
-                in millimeters.
+            positions (List[float]): A list of positions for the axes of the gantry to move to, in millimeters.
+            speeds (List[float]): A list of speeds in millimeters per second for the gantry to move at respective to each axis.
+
+        For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/#movetoposition>`_.
         """
         ...
 
+    @abc.abstractmethod
+    async def home(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> bool:
+        """
+        Run the homing sequence of the gantry to re-calibrate the axes with respect to the limit switches.
+
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            await my_gantry.home()
+
+        Returns:
+            bool: Whether the gantry has run the homing sequence successfully.
+
+        For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/#home>`_.
+        """
+
     @abc.abstractmethod
     async def get_lengths(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[float]:
         """
         Get the lengths of the axes of the gantry in millimeters.
 
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            # Get the lengths of the axes of the gantry in millimeters.
+            lengths_mm = await my_gantry.get_lengths()
+
         Returns:
-            List[float]: The lengths of the axes.
+            List[float]: A list of the lengths of the axes of the gantry in millimeters.
+
+        For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/#getlengths>`_.
         """
         ...
 
@@ -59,6 +120,16 @@ class Gantry(ComponentBase):
     async def stop(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs):
         """
         Stop all motion of the gantry. It is assumed that the gantry stops immediately.
+
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            # Stop all motion of the gantry. It is assumed that the gantry stops
+            # immediately.
+            await my_gantry.stop()
+
+        For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/#stop>`_.
         """
         ...
 
@@ -67,7 +138,50 @@ class Gantry(ComponentBase):
         """
         Get if the gantry is currently moving.
 
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            # Stop all motion of the gantry. It is assumed that the
+            # gantry stops immediately.
+            await my_gantry.stop()
+
+            # Print if the gantry is currently moving.
+            print(await my_gantry.is_moving())
+
         Returns:
             bool: Whether the gantry is moving.
+
+        For more information, see `Gantry component <https://docs.viam.com/dev/reference/apis/components/gantry/#ismoving>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_kinematics(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
+        """
+        Get the kinematics information associated with the gantry.
+
+        ::
+
+            my_gantry = Gantry.from_robot(robot=machine, name="my_gantry")
+
+            # Get the kinematics information associated with the gantry.
+            kinematics = await my_gantry.get_kinematics()
+
+            # Get the format of the kinematics file.
+            k_file = kinematics[0]
+
+            # Get the byte contents of the file.
+            k_bytes = kinematics[1]
+
+        Returns:
+            Tuple[KinematicsFileFormat.ValueType, bytes]: A tuple containing two values; the first [0] value represents the format of the
+            file, either in URDF format (``KinematicsFileFormat.KINEMATICS_FILE_FORMAT_URDF``) or
+            Viam's kinematic parameter format (spatial vector algebra) (``KinematicsFileFormat.KINEMATICS_FILE_FORMAT_SVA``),
+            and the second [1] value represents the byte contents of the file.
+
+        For more information, see `Arm component <https://docs.viam.com/dev/reference/apis/components/arm/#getkinematics>`_.
         """
         ...

viam/components/gantry/service.py

@@ -1,19 +1,27 @@
 from grpclib.server import Stream
 
-from viam.errors import ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetKinematicsRequest,
+    GetKinematicsResponse,
+)
 from viam.proto.component.gantry import (
-    GantryServiceBase,
     GetLengthsRequest,
     GetLengthsResponse,
     GetPositionRequest,
     GetPositionResponse,
+    HomeRequest,
+    HomeResponse,
     IsMovingRequest,
     IsMovingResponse,
     MoveToPositionRequest,
     MoveToPositionResponse,
     StopRequest,
     StopResponse,
+    UnimplementedGantryServiceBase,
 )
 from viam.resource.rpc_service_base import ResourceRPCServiceBase
 from viam.utils import dict_to_struct, struct_to_dict
@@ -21,7 +29,7 @@ from viam.utils import dict_to_struct, struct_to_dict
 from .gantry import Gantry
 
 
-class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
+class GantryRPCService(UnimplementedGantryServiceBase, ResourceRPCServiceBase[Gantry]):
     """
     gRPC Service for a Gantry
     """
@@ -32,10 +40,7 @@ class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gantry = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gantry = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         position = await gantry.get_position(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetPositionResponse(positions_mm=position)
@@ -45,25 +50,33 @@ class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gantry = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gantry = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await gantry.move_to_position(
-            list(request.positions_mm), extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
+            list(request.positions_mm),
+            list(request.speeds_mm_per_sec),
+            extra=struct_to_dict(request.extra),
+            timeout=timeout,
+            metadata=stream.metadata,
         )
         response = MoveToPositionResponse()
         await stream.send_message(response)
 
+    async def Home(self, stream: Stream[HomeRequest, HomeResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        gantry = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        homed = await gantry.home(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = HomeResponse(homed=homed)
+        await stream.send_message(response)
+
     async def GetLengths(self, stream: Stream[GetLengthsRequest, GetLengthsResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gantry = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gantry = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         lengths = await gantry.get_lengths(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetLengthsResponse(lengths_mm=lengths)
@@ -73,10 +86,7 @@ class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gantry = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gantry = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await gantry.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = StopResponse()
@@ -86,10 +96,7 @@ class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            gantry = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gantry = self.get_resource(name)
         is_moving = await gantry.is_moving()
         response = IsMovingResponse(is_moving=is_moving)
         await stream.send_message(response)
@@ -97,11 +104,26 @@ class GantryRPCService(GantryServiceBase, ResourceRPCServiceBase[Gantry]):
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            gantry = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        gantry = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await gantry.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)
+
+    async def GetKinematics(self, stream: Stream[GetKinematicsRequest, GetKinematicsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        gantry = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        format, data = await gantry.get_kinematics(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        response = GetKinematicsResponse(format=format, kinematics_data=data)
+        await stream.send_message(response)
+
+    async def GetGeometries(self, stream: Stream[GetGeometriesRequest, GetGeometriesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        gantry = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await gantry.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)