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

viam/components/button/client.py

@@ -0,0 +1,52 @@
+from typing import Any, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.gen.component.button.v1.button_pb2 import PushRequest
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.button import ButtonServiceStub
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import (
+    ValueTypes,
+    dict_to_struct,
+    struct_to_dict,
+)
+
+from .button import Button
+
+
+class ButtonClient(Button, ReconfigurableResourceRPCClientBase):
+    """
+    gRPC client for Button component
+    """
+
+    def __init__(self, name: str, channel: Channel):
+        self.channel = channel
+        self.client = ButtonServiceStub(channel)
+        super().__init__(name)
+
+    async def push(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> None:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = PushRequest(name=self.name, extra=dict_to_struct(extra))
+        await self.client.Push(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, metadata=md)
+        return struct_to_dict(response.result)

viam/components/button/service.py

@@ -0,0 +1,46 @@
+from grpclib.server import Stream
+
+from viam.gen.component.button.v1.button_pb2 import (
+    PushRequest,
+    PushResponse,
+)
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+)
+from viam.proto.component.button import ButtonServiceBase
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .button import Button
+
+
+class ButtonRPCService(ButtonServiceBase, ResourceRPCServiceBase[Button]):
+    """
+    gRPC Service for a generic Button
+    """
+
+    RESOURCE_TYPE = Button
+
+    async def Push(self, stream: Stream[PushRequest, PushResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        button = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await button.push(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(PushResponse())
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        button = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await button.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/components/camera/__init__.py

@@ -13,7 +13,7 @@ __all__ = [
     "ViamImage",
 ]
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         Camera,
         CameraRPCService,

viam/components/camera/camera.py

@@ -1,11 +1,11 @@
 import abc
 import sys
-from typing import Any, Dict, Final, List, Optional, Tuple
+from typing import Any, Dict, Final, Optional, Sequence, Tuple
 
 from viam.media.video import NamedImage, ViamImage
 from viam.proto.common import ResponseMetadata
 from viam.proto.component.camera import GetPropertiesResponse
-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
 
@@ -27,10 +27,10 @@ class Camera(ComponentBase):
 
         from viam.components.camera import Camera
 
-    For more information, see `Camera component <https://docs.viam.com/components/camera/>`_.
+    For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/>`_.
     """
 
-    SUBTYPE: Final = Subtype(  # pyright: ignore [reportIncompatibleVariableOverride]
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
         RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "camera"
     )
 
@@ -48,14 +48,9 @@ class Camera(ComponentBase):
 
         ::
 
-            my_camera = Camera.from_robot(robot=robot, name="my_camera")
-
-            # Assume "frame" has a mime_type of "image/vnd.viam.dep"
-            frame = await my_camera.get_image(mime_type = CameraMimeType.VIAM_RAW_DEPTH)
-
-            # Convert "frame" to a standard 2D image representation.
-            # Remove the 1st 3x8 bytes and reshape the raw bytes to List[List[Int]].
-            standard_frame = frame.bytes_to_depth_array()
+            my_camera = Camera.from_robot(machine, "my_camera")
+            frame = await my_camera.get_image()
+            print(f"Frame: {frame}")
 
         Args:
             mime_type (str): The desired mime type of the image. This does not guarantee output type
@@ -63,28 +58,39 @@ class Camera(ComponentBase):
         Returns:
             ViamImage: The frame.
 
-        For more information, see `Camera component <https://docs.viam.com/components/camera/>`_.
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getimage>`_.
         """
         ...
 
     @abc.abstractmethod
-    async def get_images(self, *, timeout: Optional[float] = None, **kwargs) -> Tuple[List[NamedImage], ResponseMetadata]:
+    async def get_images(
+        self,
+        *,
+        filter_source_names: Optional[Sequence[str]] = None,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Tuple[Sequence[NamedImage], ResponseMetadata]:
         """Get simultaneous images from different imagers, along with associated metadata.
         This should not be used for getting a time series of images from the same imager.
 
         ::
 
-            my_camera = Camera.from_robot(robot=robot, name="my_camera")
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
 
             images, metadata = await my_camera.get_images()
-            img0 = images[0].image
+            first_image = images[0]
             timestamp = metadata.captured_at
 
+        Args:
+            filter_source_names (Sequence[str]): The filter_source_names parameter can be used to filter only the images from the specified
+                source names. When unspecified, all images are returned.
+
         Returns:
-            Tuple[List[NamedImage], ResponseMetadata]: A tuple containing two values; the first [0] a list of images
+            Tuple[Sequence[NamedImage], ResponseMetadata]: A tuple containing two values; the first [0] a list of images
             returned from the camera system, and the second [1] the metadata associated with this response.
 
-        For more information, see `Camera component <https://docs.viam.com/components/camera/>`_.
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getimages>`_.
         """
         ...
 
@@ -100,12 +106,15 @@ class Camera(ComponentBase):
         by the mimetype.
 
         To deserialize the returned information into a numpy array, use the Open3D library.
+
         ::
 
             import numpy as np
             import open3d as o3d
 
-            data, _ = await camera.get_point_cloud()
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
+
+            data, _ = await my_camera.get_point_cloud()
 
             # write the point cloud into a temporary file
             with open("/tmp/pointcloud_data.pcd", "wb") as f:
@@ -117,7 +126,7 @@ class Camera(ComponentBase):
             Tuple[bytes, str]: A tuple containing two values; the first [0] the pointcloud data,
             and the second [1] the mimetype of the pointcloud (for example, PCD).
 
-        For more information, see `Camera component <https://docs.viam.com/components/camera/>`_.
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getpointcloud>`_.
         """
         ...
 
@@ -128,13 +137,13 @@ class Camera(ComponentBase):
 
         ::
 
-            my_camera = Camera.from_robot(robot=robot, name="my_camera")
+            my_camera = Camera.from_robot(robot=machine, name="my_camera")
 
             properties = await my_camera.get_properties()
 
         Returns:
             Properties: The properties of the camera.
 
-        For more information, see `Camera component <https://docs.viam.com/components/camera/>`_.
+        For more information, see `Camera component <https://docs.viam.com/dev/reference/apis/components/camera/#getproperties>`_.
         """
         ...

viam/components/camera/client.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Mapping, Optional, Tuple
+from typing import Any, Dict, Mapping, Optional, Sequence, Tuple
 
 from grpclib.client import Channel
 
@@ -36,25 +36,31 @@ class CameraClient(Camera, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        **__,
+        **kwargs,
     ) -> ViamImage:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetImageRequest(name=self.name, mime_type=mime_type, extra=dict_to_struct(extra))
-        response: GetImageResponse = await self.client.GetImage(request, timeout=timeout)
+        response: GetImageResponse = await self.client.GetImage(request, timeout=timeout, metadata=md)
         return ViamImage(response.image, CameraMimeType.from_string(response.mime_type))
 
     async def get_images(
         self,
         *,
+        filter_source_names: Optional[Sequence[str]] = None,
+        extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        **__,
-    ) -> Tuple[List[NamedImage], ResponseMetadata]:
-        request = GetImagesRequest(name=self.name)
-        response: GetImagesResponse = await self.client.GetImages(request, timeout=timeout)
+        **kwargs,
+    ) -> Tuple[Sequence[NamedImage], ResponseMetadata]:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = GetImagesRequest(name=self.name, extra=dict_to_struct(extra), filter_source_names=filter_source_names)
+        response: GetImagesResponse = await self.client.GetImages(request, timeout=timeout, metadata=md)
         imgs = []
         for img_data in response.images:
-            mime_type = CameraMimeType.from_proto(img_data.format)
+            if img_data.mime_type:
+                mime_type = CameraMimeType.from_string(img_data.mime_type)
+            else:
+                # TODO(RSDK-11728): remove this once we deleted the format field
+                mime_type = CameraMimeType.from_proto(img_data.format)
             img = NamedImage(img_data.source_name, img_data.image, mime_type)
             imgs.append(img)
         resp_metadata: ResponseMetadata = response.response_metadata
@@ -65,32 +71,36 @@ class CameraClient(Camera, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        **__,
+        **kwargs,
     ) -> Tuple[bytes, str]:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPointCloudRequest(name=self.name, mime_type=CameraMimeType.PCD, extra=dict_to_struct(extra))
-        response: GetPointCloudResponse = await self.client.GetPointCloud(request, timeout=timeout)
+        response: GetPointCloudResponse = await self.client.GetPointCloud(request, timeout=timeout, metadata=md)
         return (response.point_cloud, response.mime_type)
 
     async def get_properties(
         self,
         *,
         timeout: Optional[float] = None,
-        **__,
+        **kwargs,
     ) -> Camera.Properties:
-        return await self.client.GetProperties(GetPropertiesRequest(name=self.name), timeout=timeout)
+        md = kwargs.get("metadata", self.Metadata()).proto
+        return await self.client.GetProperties(GetPropertiesRequest(name=self.name), 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)
 
-    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[Geometry]:
-        return await get_geometries(self.client, self.name, extra, timeout)
+    async def get_geometries(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> Sequence[Geometry]:
+        md = kwargs.get("metadata", self.Metadata())
+        return await get_geometries(self.client, self.name, extra, timeout, md)

viam/components/camera/service.py

@@ -3,6 +3,7 @@
 from google.api.httpbody_pb2 import HttpBody  # type: ignore
 from grpclib.server import Stream
 
+from viam.media.video import CameraMimeType
 from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
 from viam.proto.component.camera import (
     CameraServiceBase,
@@ -44,16 +45,23 @@ class CameraRPCService(CameraServiceBase, ResourceRPCServiceBase[Camera]):
     async def GetImages(self, stream: Stream[GetImagesRequest, GetImagesResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        name = request.name
-        camera = self.get_resource(name)
+        camera = self.get_resource(request.name)
 
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        images, metadata = await camera.get_images(timeout=timeout, metadata=stream.metadata)
+        images, metadata = await camera.get_images(
+            timeout=timeout,
+            metadata=stream.metadata,
+            extra=struct_to_dict(request.extra),
+            filter_source_names=request.filter_source_names,
+        )
         img_bytes_lst = []
         for img in images:
-            fmt = img.mime_type.to_proto()
+            mime_type = CameraMimeType.from_string(img.mime_type)
+            # TODO(RSDK-11728): remove this fmt logic once we deleted the format field
+            fmt = mime_type.to_proto()  # Will be Format.FORMAT_UNSPECIFIED if an unsupported/custom mime type is set
+
             img_bytes = img.data
-            img_bytes_lst.append(Image(source_name=name, format=fmt, image=img_bytes))
+            img_bytes_lst.append(Image(source_name=img.name, mime_type=img.mime_type, format=fmt, image=img_bytes))
         response = GetImagesResponse(images=img_bytes_lst, response_metadata=metadata)
         await stream.send_message(response)
 
@@ -84,13 +92,7 @@ class CameraRPCService(CameraServiceBase, ResourceRPCServiceBase[Camera]):
         camera = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         properties = await camera.get_properties(timeout=timeout, metadata=stream.metadata)
-        response = GetPropertiesResponse(
-            supports_pcd=properties.supports_pcd,
-            intrinsic_parameters=properties.intrinsic_parameters,
-            distortion_parameters=properties.distortion_parameters,
-            mime_types=properties.mime_types,
-        )
-        await stream.send_message(response)
+        await stream.send_message(properties)
 
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()

viam/components/component_base.py

@@ -1,14 +1,16 @@
 import abc
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Mapping, Optional, SupportsBytes, SupportsFloat, Union, cast
+from logging import Logger
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Mapping, Optional, Sequence, SupportsBytes, SupportsFloat, Union, cast
 
 from typing_extensions import Self
 
 from viam.errors import MethodNotImplementedError
+from viam.logging import getLogger
 from viam.proto.common import Geometry
 from viam.resource.base import ResourceBase
 
 if TYPE_CHECKING:
-    from viam.resource.types import Subtype
+    from viam.resource.types import API
     from viam.robot.client import RobotClient
 
 
@@ -21,10 +23,11 @@ class ComponentBase(abc.ABC, ResourceBase):
     All components must inherit from this class.
     """
 
-    SUBTYPE: ClassVar["Subtype"]
+    API: ClassVar["API"]
 
-    def __init__(self, name: str):
+    def __init__(self, name: str, *, logger: Optional[Logger] = 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:
@@ -38,15 +41,15 @@ class ComponentBase(abc.ABC, ResourceBase):
             Self: The component, if it exists on the robot
         """
         component = robot.get_component(cls.get_resource_name(name))
-        return cast(cls, component)
+        return cast(cls, component)  # type: ignore
 
     async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None, **kwargs) -> Mapping[str, ValueTypes]:
         raise NotImplementedError()
 
-    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[Geometry]:
+    async def get_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Sequence[Geometry]:
         """
         Get all geometries associated with the component, in their current configuration, in the
-        `frame <https://docs.viam.com/services/frame-system/>`__ of the component.
+        `frame <https://docs.viam.com/operate/mobility/define-geometry/>`__ of the component.
 
         ::
 

viam/components/encoder/__init__.py

@@ -9,7 +9,7 @@ __all__ = [
 ]
 
 
-Registry.register_subtype(
+Registry.register_api(
     ResourceRegistration(
         Encoder,
         EncoderRPCService,

viam/components/encoder/client.py

@@ -33,12 +33,11 @@ class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        **__,
+        **kwargs,
     ):
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = ResetPositionRequest(name=self.name, extra=dict_to_struct(extra))
-        await self.client.ResetPosition(request, timeout=timeout)
+        await self.client.ResetPosition(request, timeout=timeout, metadata=md)
 
     async def get_position(
         self,
@@ -46,12 +45,11 @@ class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        **__,
+        **kwargs,
     ) -> Tuple[float, PositionType.ValueType]:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPositionRequest(name=self.name, position_type=position_type, 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 response.value, response.position_type
 
     async def get_properties(
@@ -59,12 +57,11 @@ class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        **__,
+        **kwargs,
     ) -> Encoder.Properties:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetPropertiesRequest(name=self.name, extra=dict_to_struct(extra))
-        response: GetPropertiesResponse = await self.client.GetProperties(request, timeout=timeout)
+        response: GetPropertiesResponse = await self.client.GetProperties(request, timeout=timeout, metadata=md)
         return Encoder.Properties(
             ticks_count_supported=response.ticks_count_supported, angle_degrees_supported=response.angle_degrees_supported
         )
@@ -74,11 +71,13 @@ class EncoderClient(Encoder, ReconfigurableResourceRPCClientBase):
         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_geometries(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[Geometry]:
-        return await get_geometries(self.client, self.name, extra, timeout)
+    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/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
 
@@ -25,10 +25,10 @@ class Encoder(ComponentBase):
 
         from viam.components.encoder import Encoder
 
-    For more information, see `Encoder component <https://docs.viam.com/components/encoder/>`_.
+    For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/>`_.
     """
 
-    SUBTYPE: Final = Subtype(  # pyright: ignore [reportIncompatibleVariableOverride]
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
         RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "encoder"
     )
 
@@ -45,13 +45,13 @@ class Encoder(ComponentBase):
 
         ::
 
-            my_encoder = Encoder.from_robot(robot=robot, name='my_encoder')
+            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/components/encoder/>`_.
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#resetposition>`_.
         """
         ...
 
@@ -73,7 +73,7 @@ class Encoder(ComponentBase):
 
         ::
 
-            my_encoder = Encoder.from_robot(robot=robot, name='my_encoder')
+            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)
@@ -88,7 +88,7 @@ class Encoder(ComponentBase):
             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/components/encoder/>`_.
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#getposition>`_.
         """
         ...
 
@@ -105,7 +105,7 @@ class Encoder(ComponentBase):
 
         ::
 
-            my_encoder = Encoder.from_robot(robot=robot, name='my_encoder')
+            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()
@@ -113,6 +113,6 @@ class Encoder(ComponentBase):
         Returns:
             Encoder.Properties: Map of position types to supported status.
 
-        For more information, see `Encoder component <https://docs.viam.com/components/encoder/>`_.
+        For more information, see `Encoder component <https://docs.viam.com/dev/reference/apis/components/encoder/#getproperties>`_.
         """
         ...

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)))