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

viam/components/base/client.py

@@ -1,10 +1,12 @@
-from typing import Any, Dict, Mapping, Optional
+from typing import Any, Dict, List, Mapping, Optional
 
 from grpclib.client import Channel
 
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
 from viam.proto.component.base import (
     BaseServiceStub,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
     IsMovingRequest,
     IsMovingResponse,
     MoveStraightRequest,
@@ -14,7 +16,7 @@ from viam.proto.component.base import (
     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 . import Base, Vector3
 
@@ -36,16 +38,16 @@ class BaseClient(Base, 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 = MoveStraightRequest(
             name=self.name,
             distance_mm=distance,
             mm_per_sec=velocity,
             extra=dict_to_struct(extra),
         )
-        await self.client.MoveStraight(request, timeout=timeout)
+        await self.client.MoveStraight(request, timeout=timeout, metadata=md)
 
     async def spin(
         self,
@@ -54,16 +56,16 @@ class BaseClient(Base, 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 = SpinRequest(
             name=self.name,
             angle_deg=angle,
             degs_per_sec=velocity,
             extra=dict_to_struct(extra),
         )
-        await self.client.Spin(request, timeout=timeout)
+        await self.client.Spin(request, timeout=timeout, metadata=md)
 
     async def set_power(
         self,
@@ -72,16 +74,16 @@ class BaseClient(Base, 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 = SetPowerRequest(
             name=self.name,
             linear=linear,
             angular=angular,
             extra=dict_to_struct(extra),
         )
-        await self.client.SetPower(request, timeout=timeout)
+        await self.client.SetPower(request, timeout=timeout, metadata=md)
 
     async def set_velocity(
         self,
@@ -90,36 +92,62 @@ class BaseClient(Base, 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 = SetVelocityRequest(name=self.name, linear=linear, angular=angular, extra=dict_to_struct(extra))
-        await self.client.SetVelocity(request, timeout=timeout)
+        await self.client.SetVelocity(request, timeout=timeout, metadata=md)
 
     async def stop(
         self,
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ):
-        if extra is None:
-            extra = {}
+        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 get_properties(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Base.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 Base.Properties(
+            width_meters=response.width_meters,
+            turning_radius_meters=response.turning_radius_meters,
+            wheel_circumference_meters=response.wheel_circumference_meters,
+        )
+
     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, **kwargs) -> List[Geometry]:
+        md = kwargs.get("metadata", self.Metadata())
+        return await get_geometries(self.client, self.name, extra, timeout, md)

viam/components/base/service.py

@@ -1,9 +1,10 @@
 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.base import (
     BaseServiceBase,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
     IsMovingRequest,
     IsMovingResponse,
     MoveStraightRequest,
@@ -34,10 +35,7 @@ class BaseRPCService(BaseServiceBase, ResourceRPCServiceBase[Base]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            base = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        base = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await base.move_straight(
             distance=request.distance_mm,
@@ -53,10 +51,7 @@ class BaseRPCService(BaseServiceBase, ResourceRPCServiceBase[Base]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            base = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        base = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await base.spin(
             angle=request.angle_deg,
@@ -72,10 +67,7 @@ class BaseRPCService(BaseServiceBase, ResourceRPCServiceBase[Base]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            base = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        base = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await base.set_power(
             request.linear, request.angular, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
@@ -87,10 +79,7 @@ class BaseRPCService(BaseServiceBase, ResourceRPCServiceBase[Base]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            base = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        base = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await base.set_velocity(
             request.linear, request.angular, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata
@@ -101,10 +90,7 @@ class BaseRPCService(BaseServiceBase, ResourceRPCServiceBase[Base]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            base = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        base = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         await base.stop(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = StopResponse()
@@ -114,22 +100,39 @@ class BaseRPCService(BaseServiceBase, ResourceRPCServiceBase[Base]):
         request = await stream.recv_message()
         assert request is not None
         name = request.name
-        try:
-            base = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        base = self.get_resource(name)
         is_moving = await base.is_moving()
         response = IsMovingResponse(is_moving=is_moving)
         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
+        base = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await base.get_properties(timeout=timeout, metadata=stream.metadata)
+        response = GetPropertiesResponse(
+            width_meters=properties.width_meters,
+            turning_radius_meters=properties.turning_radius_meters,
+            wheel_circumference_meters=properties.wheel_circumference_meters,
+        )
+        await stream.send_message(response)
+
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            base = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        base = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await base.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
+        base = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await base.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/board/__init__.py

@@ -1,18 +1,9 @@
-from viam.proto.robot import Status
 from viam.resource.registry import Registry, ResourceRegistration
-from viam.utils import message_to_struct
 
-from .board import Board
+from .board import Board, Tick, TickStream
 from .client import BoardClient
 from .service import BoardRPCService
 
-__all__ = [
-    "Board",
-]
+__all__ = ["Board", "Tick", "TickStream"]
 
-
-async def create_status(component: Board) -> Status:
-    return Status(name=Board.get_resource_name(component.name), status=message_to_struct(await component.status()))
-
-
-Registry.register_subtype(ResourceRegistration(Board, BoardRPCService, lambda name, channel: BoardClient(name, channel), create_status))
+Registry.register_api(ResourceRegistration(Board, BoardRPCService, lambda name, channel: BoardClient(name, channel)))