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

viam/services/slam/slam.py

@@ -1,11 +1,18 @@
 import abc
+import sys
 from typing import Final, List, Optional
 
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, Subtype
+from viam.proto.service.slam import GetPropertiesResponse
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
 
 from ..service_base import ServiceBase
 from . import Pose
 
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
 
 class SLAM(ServiceBase):
     """
@@ -14,28 +21,54 @@ class SLAM(ServiceBase):
     This acts as an abstract base class for any drivers representing specific
     arm 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 `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "slam")
+    API: Final = API(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "slam")  # pyright: ignore [reportIncompatibleVariableOverride]
+
+    Properties: "TypeAlias" = GetPropertiesResponse
 
     @abc.abstractmethod
     async def get_internal_state(self, *, timeout: Optional[float]) -> List[bytes]:
-        """Get the internal state of the SLAM algorithm required to continue mapping/localization.
+        """
+        Get the internal state of the SLAM algorithm required to continue mapping/localization.
+
+        ::
+
+            slam = SLAMClient.from_robot(robot=machine, name="my_slam_service")
+
+            # Get the internal state of the SLAM algorithm required to continue mapping/localization.
+            internal_state = await slam.get_internal_state()
 
         Returns:
             List[GetInternalStateResponse]: Chunks of the internal state of the SLAM algorithm
 
+        For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getinternalstate>`_.
         """
         ...
 
     @abc.abstractmethod
-    async def get_point_cloud_map(self, *, timeout: Optional[float]) -> List[bytes]:
+    async def get_point_cloud_map(self, return_edited_map: bool = False, *, timeout: Optional[float]) -> List[bytes]:
         """
         Get the point cloud map.
 
+        ::
+
+            slam_svc = SLAMClient.from_robot(robot=machine, name="my_slam_service")
+
+            # Get the point cloud map in standard PCD format.
+            pcd_map = await slam_svc.get_point_cloud_map()
+
+        Args:
+            return_edited_map (bool): signal to the SLAM service to return an edited map, if the map package contains one and if
+                the SLAM service supports the feature
+
         Returns:
             List[GetPointCloudMapResponse]: Complete pointcloud in standard PCD format. Chunks of the PointCloud, concatenating all
-                GetPointCloudMapResponse.point_cloud_pcd_chunk values
+            GetPointCloudMapResponse.point_cloud_pcd_chunk values.
+
+        For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getpointcloudmap>`_.
         """
         ...
 
@@ -44,7 +77,35 @@ class SLAM(ServiceBase):
         """
         Get current position of the specified component in the SLAM Map.
 
+        ::
+
+            slam_svc = SLAMClient.from_robot(robot=machine, name="my_slam_service")
+
+            # Get the current position of the specified source component in the SLAM map as a Pose.
+            pose = await slam.get_position()
+
         Returns:
             Pose: The current position of the specified component
+
+        For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getposition>`_.
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_properties(self, *, timeout: Optional[float]) -> Properties:
+        """
+        Get information regarding the current SLAM session.
+
+        ::
+
+            slam_svc = SLAMClient.from_robot(robot=machine, name="my_slam_service")
+
+            # Get the properties of your current SLAM session.
+            slam_properties = await slam_svc.get_properties()
+
+        Returns:
+            Properties: The properties of SLAM
+
+        For more information, see `SLAM service <https://docs.viam.com/dev/reference/apis/services/slam/#getproperties>`_.
         """
         ...

viam/services/vision/__init__.py

@@ -1,7 +1,15 @@
+from viam.resource.registry import Registry, ResourceRegistration
+from viam.services.vision.service import VisionRPCService
+
 from .client import Classification, Detection, VisionClient
+from .vision import CaptureAllResult, Vision
 
 __all__ = [
+    "CaptureAllResult",
     "Classification",
     "Detection",
     "VisionClient",
+    "Vision",
 ]
+
+Registry.register_api(ResourceRegistration(Vision, VisionRPCService, lambda name, channel: VisionClient(name, channel)))

viam/services/vision/client.py

@@ -1,12 +1,13 @@
-from io import BytesIO
-from typing import Any, Final, List, Mapping, Optional, Union
+from typing import Any, List, Mapping, Optional
 
 from grpclib.client import Channel
 
-from viam.media.viam_rgba_plugin import Image
-from viam.media.video import CameraMimeType, RawImage
+from viam.errors import ViamError
+from viam.media.video import CameraMimeType, ViamImage
 from viam.proto.common import DoCommandRequest, DoCommandResponse, PointCloudObject
 from viam.proto.service.vision import (
+    CaptureAllFromCameraRequest,
+    CaptureAllFromCameraResponse,
     Classification,
     Detection,
     GetClassificationsFromCameraRequest,
@@ -19,78 +20,102 @@ from viam.proto.service.vision import (
     GetDetectionsResponse,
     GetObjectPointCloudsRequest,
     GetObjectPointCloudsResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
     VisionServiceStub,
 )
 from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, Subtype
-from viam.services.service_client_base import ServiceClientBase
 from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
 
+from .vision import CaptureAllResult, Vision
 
-class VisionClient(ServiceClientBase, ReconfigurableResourceRPCClientBase):
+
+class VisionClient(Vision, ReconfigurableResourceRPCClientBase):
     """
     Connect to the Vision service, which allows you to access various computer vision algorithms
     (like detection, segmentation, tracking, etc) that usually only require a camera or image input.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "vision")
     client: VisionServiceStub
 
     def __init__(self, name: str, channel: Channel):
-        super().__init__(name, channel)
+        super().__init__(name)
+        self.channel = channel
         self.client = VisionServiceStub(channel)
 
+    async def capture_all_from_camera(
+        self,
+        camera_name: str,
+        return_image: bool = False,
+        return_classifications: bool = False,
+        return_detections: bool = False,
+        return_object_point_clouds: bool = False,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> CaptureAllResult:
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = CaptureAllFromCameraRequest(
+            name=self.name,
+            camera_name=camera_name,
+            return_image=return_image,
+            return_classifications=return_classifications,
+            return_detections=return_detections,
+            return_object_point_clouds=return_object_point_clouds,
+            extra=dict_to_struct(extra),
+        )
+        response: CaptureAllFromCameraResponse = await self.client.CaptureAllFromCamera(request, timeout=timeout, metadata=md)
+        result = CaptureAllResult()
+        result.extra = struct_to_dict(response.extra)
+        if return_image:
+            mime_type = CameraMimeType.from_string(response.image.mime_type)
+            img = ViamImage(response.image.image, mime_type)
+            result.image = img
+        if return_classifications:
+            result.classifications = list(response.classifications)
+        if return_detections:
+            result.detections = list(response.detections)
+        if return_object_point_clouds:
+            result.objects = list(response.objects)
+        return result
+
     async def get_detections_from_camera(
-        self, camera_name: str, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None
+        self,
+        camera_name: str,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
     ) -> List[Detection]:
-        """Get a list of detections in the next image given a camera and a detector
-
-        Args:
-            camera_name (str): The name of the camera to use for detection
-
-        Returns:
-            List[viam.proto.service.vision.Detection]: A list of 2D bounding boxes, their labels, and the
-            confidence score of the labels, around the found objects in the next 2D image
-            from the given camera, with the given detector applied to it.
-        """
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetDetectionsFromCameraRequest(name=self.name, camera_name=camera_name, extra=dict_to_struct(extra))
-        response: GetDetectionsFromCameraResponse = await self.client.GetDetectionsFromCamera(request, timeout=timeout)
+        response: GetDetectionsFromCameraResponse = await self.client.GetDetectionsFromCamera(request, timeout=timeout, metadata=md)
         return list(response.detections)
 
     async def get_detections(
         self,
-        image: Union[Image.Image, RawImage],
+        image: ViamImage,
         *,
         extra: Optional[Mapping[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> List[Detection]:
-        """Get a list of detections in the given image using the specified detector
-
-        Args:
-            image (Image): The image to get detections from
-
-        Returns:
-            List[viam.proto.service.vision.Detection]: A list of 2D bounding boxes, their labels, and the
-            confidence score of the labels, around the found objects in the next 2D image
-            from the given camera, with the given detector applied to it.
-        """
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         mime_type = CameraMimeType.JPEG
-        if isinstance(image, RawImage):
-            image = Image.open(BytesIO(image.data), formats=[mime_type.name])
 
-        request = GetDetectionsRequest(
-            name=self.name,
-            image=mime_type.encode_image(image),
-            width=image.width,
-            height=image.height,
-            mime_type=mime_type,
-            extra=dict_to_struct(extra),
-        )
-        response: GetDetectionsResponse = await self.client.GetDetections(request, timeout=timeout)
+        if image.width is None or image.height is None:
+            raise ViamError(f"image {image} needs to have a specified width and height")
+        else:
+            request = GetDetectionsRequest(
+                name=self.name,
+                image=image.data,
+                width=image.width,
+                height=image.height,
+                mime_type=mime_type,
+                extra=dict_to_struct(extra),
+            )
+        response: GetDetectionsResponse = await self.client.GetDetections(request, timeout=timeout, metadata=md)
         return list(response.detections)
 
     async def get_classifications_from_camera(
@@ -100,103 +125,82 @@ class VisionClient(ServiceClientBase, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Mapping[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> List[Classification]:
-        """Get a list of classifications in the next image given a camera and a classifier
-
-        Args:
-            camera_name (str): The name of the camera to use for detection
-            count (int): The number of classifications desired
-
-        returns:
-            List[viam.proto.service.vision.Classification]: The list of Classifications
-        """
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetClassificationsFromCameraRequest(name=self.name, camera_name=camera_name, n=count, extra=dict_to_struct(extra))
-        response: GetClassificationsFromCameraResponse = await self.client.GetClassificationsFromCamera(request, timeout=timeout)
+        response: GetClassificationsFromCameraResponse = await self.client.GetClassificationsFromCamera(
+            request, timeout=timeout, metadata=md
+        )
         return list(response.classifications)
 
     async def get_classifications(
         self,
-        image: Union[Image.Image, RawImage],
+        image: ViamImage,
         count: int,
         *,
         extra: Optional[Mapping[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> List[Classification]:
-        """Get a list of detections in the given image using the specified detector
+        md = kwargs.get("metadata", self.Metadata()).proto
 
-        Args:
-            image (Image): The image to get detections from
-
-        Returns:
-            List[viam.proto.service.vision.Classification]: The list of Classifications
-        """
-        if extra is None:
-            extra = {}
         mime_type = CameraMimeType.JPEG
-        if isinstance(image, RawImage):
-            image = Image.open(BytesIO(image.data), formats=[mime_type.name])
-
+        if image.width is None or image.height is None:
+            raise ViamError(f"image {image} needs to have a specified width and height")
         request = GetClassificationsRequest(
             name=self.name,
-            image=mime_type.encode_image(image),
+            image=image.data,
             width=image.width,
             height=image.height,
             mime_type=mime_type,
             n=count,
             extra=dict_to_struct(extra),
         )
-        response: GetClassificationsResponse = await self.client.GetClassifications(request, timeout=timeout)
+        response: GetClassificationsResponse = await self.client.GetClassifications(request, timeout=timeout, metadata=md)
         return list(response.classifications)
 
     async def get_object_point_clouds(
-        self, camera_name: str, *, extra: Optional[Mapping[str, Any]] = None, timeout: Optional[float] = None
+        self,
+        camera_name: str,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
     ) -> List[PointCloudObject]:
-        """
-        Returns a list of the 3D point cloud objects and associated metadata in the latest
-        picture obtained from the specified 3D camera (using the specified segmenter).
-
-        To deserialize the returned information into a numpy array, use the Open3D library.
-        ::
-
-            import numpy as np
-            import open3d as o3d
-
-            object_point_clouds = await vision.get_object_point_clouds(camera_name, segmenter_name)
-
-            # write the first object point cloud into a temporary file
-            with open("/tmp/pointcloud_data.pcd", "wb") as f:
-                f.write(object_point_clouds[0].point_cloud)
-            pcd = o3d.io.read_point_cloud("/tmp/pointcloud_data.pcd")
-            points = np.asarray(pcd.points)
-
-        Args:
-            camera_name (str): The name of the camera
-
-        Returns:
-            List[viam.proto.common.PointCloudObject]: The pointcloud objects with metadata
-        """
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetObjectPointCloudsRequest(
             name=self.name,
             camera_name=camera_name,
             mime_type=CameraMimeType.PCD,
             extra=dict_to_struct(extra),
         )
-        response: GetObjectPointCloudsResponse = await self.client.GetObjectPointClouds(request, timeout=timeout)
+        response: GetObjectPointCloudsResponse = await self.client.GetObjectPointClouds(request, timeout=timeout, metadata=md)
         return list(response.objects)
 
-    async def do_command(self, command: Mapping[str, ValueTypes], *, timeout: Optional[float] = None) -> Mapping[str, ValueTypes]:
-        """Send/receive arbitrary commands
-
-        Args:
-            command (Dict[str, ValueTypes]): The command to execute
+    async def get_properties(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Vision.Properties:
+        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, metadata=md)
+        return response
 
-        Returns:
-            Dict[str, ValueTypes]: Result of the executed command
-        """
+    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/vision/service.py

@@ -0,0 +1,143 @@
+from grpclib.server import Stream
+
+from viam.media.video import CameraMimeType, ViamImage
+from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.component.camera import Image
+from viam.proto.service.vision import (
+    CaptureAllFromCameraRequest,
+    CaptureAllFromCameraResponse,
+    GetClassificationsFromCameraRequest,
+    GetClassificationsFromCameraResponse,
+    GetClassificationsRequest,
+    GetClassificationsResponse,
+    GetDetectionsFromCameraRequest,
+    GetDetectionsFromCameraResponse,
+    GetDetectionsRequest,
+    GetDetectionsResponse,
+    GetObjectPointCloudsRequest,
+    GetObjectPointCloudsResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+    UnimplementedVisionServiceBase,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .vision import Vision
+
+
+class VisionRPCService(UnimplementedVisionServiceBase, ResourceRPCServiceBase[Vision]):
+    """
+    gRPC service for a Vision service
+    """
+
+    RESOURCE_TYPE = Vision
+
+    async def CaptureAllFromCamera(self, stream: Stream[CaptureAllFromCameraRequest, CaptureAllFromCameraResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        vision = self.get_resource(request.name)
+        extra = struct_to_dict(request.extra)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await vision.capture_all_from_camera(
+            request.camera_name,
+            return_image=request.return_image,
+            return_classifications=request.return_classifications,
+            return_detections=request.return_detections,
+            return_object_point_clouds=request.return_object_point_clouds,
+            extra=extra,
+            timeout=timeout,
+        )
+        img = None
+        if result.image is not None:
+            img_bytes = result.image.data
+            img = Image(source_name=request.camera_name, mime_type=result.image.mime_type, image=img_bytes)
+        response = CaptureAllFromCameraResponse(
+            image=img,
+            detections=result.detections,
+            classifications=result.classifications,
+            objects=result.objects,
+            extra=dict_to_struct(result.extra if result.extra else {}),
+        )
+        await stream.send_message(response)
+
+    async def GetDetectionsFromCamera(self, stream: Stream[GetDetectionsFromCameraRequest, GetDetectionsFromCameraResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        vision = self.get_resource(request.name)
+        extra = struct_to_dict(request.extra)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await vision.get_detections_from_camera(request.camera_name, extra=extra, timeout=timeout)
+        response = GetDetectionsFromCameraResponse(detections=result)
+        await stream.send_message(response)
+
+    async def GetDetections(self, stream: Stream[GetDetectionsRequest, GetDetectionsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        vision = self.get_resource(request.name)
+        extra = struct_to_dict(request.extra)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+
+        image = ViamImage(request.image, CameraMimeType.from_string(request.mime_type))
+
+        result = await vision.get_detections(image, extra=extra, timeout=timeout)
+        response = GetDetectionsResponse(detections=result)
+        await stream.send_message(response)
+
+    async def GetClassificationsFromCamera(
+        self, stream: Stream[GetClassificationsFromCameraRequest, GetClassificationsFromCameraResponse]
+    ) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        vision = self.get_resource(request.name)
+        extra = struct_to_dict(request.extra)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await vision.get_classifications_from_camera(request.camera_name, request.n, extra=extra, timeout=timeout)
+        response = GetClassificationsFromCameraResponse(classifications=result)
+        await stream.send_message(response)
+
+    async def GetClassifications(self, stream: Stream[GetClassificationsRequest, GetClassificationsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        vision = self.get_resource(request.name)
+        extra = struct_to_dict(request.extra)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+
+        image = ViamImage(request.image, CameraMimeType.from_string(request.mime_type))
+
+        result = await vision.get_classifications(image, request.n, extra=extra, timeout=timeout)
+        response = GetClassificationsResponse(classifications=result)
+        await stream.send_message(response)
+
+    async def GetObjectPointClouds(self, stream: Stream[GetObjectPointCloudsRequest, GetObjectPointCloudsResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        vision = self.get_resource(request.name)
+        extra = struct_to_dict(request.extra)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await vision.get_object_point_clouds(request.camera_name, extra=extra, timeout=timeout)
+        response = GetObjectPointCloudsResponse(mime_type=CameraMimeType.PCD, objects=result)
+        await stream.send_message(response)
+
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        vision = self.get_resource(name)
+        extra = struct_to_dict(request.extra)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await vision.get_properties(extra=extra, timeout=timeout)
+        response = GetPropertiesResponse(
+            classifications_supported=properties.classifications_supported,
+            detections_supported=properties.detections_supported,
+            object_point_clouds_supported=properties.object_point_clouds_supported,
+        )
+        await stream.send_message(response)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        vision = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await vision.do_command(struct_to_dict(request.command), timeout=timeout)
+        await stream.send_message(DoCommandResponse(result=dict_to_struct(result)))