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

viam/components/input/client.py

@@ -10,7 +10,7 @@ from grpclib.client import Channel
 import viam
 from viam.errors import NotSupportedError
 from viam.logging import getLogger
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry
 from viam.proto.component.inputcontroller import (
     GetControlsRequest,
     GetControlsResponse,
@@ -21,8 +21,8 @@ from viam.proto.component.inputcontroller import (
     StreamEventsResponse,
     TriggerEventRequest,
 )
-from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
-from viam.utils import ValueTypes, dict_to_struct, struct_to_dict
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase, ResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
 
 from .input import Control, ControlFunction, Controller, Event, EventType
 
@@ -43,25 +43,39 @@ class ControllerClient(Controller, ReconfigurableResourceRPCClientBase):
         self._callback_extra: Struct = dict_to_struct({})
         super().__init__(name)
 
-    async def get_controls(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> List[Control]:
-        if extra is None:
-            extra = {}
+    async def get_controls(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> List[Control]:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetControlsRequest(controller=self.name, extra=dict_to_struct(extra))
-        response: GetControlsResponse = await self.client.GetControls(request, timeout=timeout)
+        response: GetControlsResponse = await self.client.GetControls(request, timeout=timeout, metadata=md)
         return [Control(control) for control in response.controls]
 
-    async def get_events(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None) -> Dict[Control, Event]:
-        if extra is None:
-            extra = {}
+    async def get_events(
+        self,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> Dict[Control, Event]:
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = GetEventsRequest(controller=self.name, extra=dict_to_struct(extra))
-        response: GetEventsResponse = await self.client.GetEvents(request, timeout=timeout)
+        response: GetEventsResponse = await self.client.GetEvents(request, timeout=timeout, metadata=md)
         return {Control(event.control): Event.from_proto(event) for (event) in response.events}
 
     def register_control_callback(
-        self, control: Control, triggers: List[EventType], function: Optional[ControlFunction], extra: Optional[Dict[str, Any]] = None
+        self,
+        control: Control,
+        triggers: List[EventType],
+        function: Optional[ControlFunction],
+        extra: Optional[Dict[str, Any]] = None,
+        **kwargs,
     ):
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata())
         self._callback_extra = dict_to_struct(extra)
         with self._lock:
             callbacks = self.callbacks.get(control, {})
@@ -82,7 +96,7 @@ class ControllerClient(Controller, ReconfigurableResourceRPCClientBase):
             except Exception:
                 LOGGER.exception("Exception raised by task = %r", task)
 
-        task = asyncio.create_task(self._stream_events(), name=f"{viam._TASK_PREFIX}-input_stream_events")
+        task = asyncio.create_task(self._stream_events(md), name=f"{viam._TASK_PREFIX}-input_stream_events")
         task.add_done_callback(handle_task_result)
 
     def reset_channel(self, channel: Channel):
@@ -92,18 +106,24 @@ class ControllerClient(Controller, ReconfigurableResourceRPCClientBase):
                 for event_type, func in callback.items():
                     self.register_control_callback(control, [event_type], func)
 
-    async def trigger_event(self, event: Event, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None):
-        if extra is None:
-            extra = {}
+    async def trigger_event(
+        self,
+        event: Event,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = TriggerEventRequest(controller=self.name, event=event.proto, extra=dict_to_struct(extra))
         try:
-            await self.client.TriggerEvent(request, timeout=timeout)
+            await self.client.TriggerEvent(request, timeout=timeout, metadata=md)
         except GRPCError as e:
             if e.status == Status.UNIMPLEMENTED and ("does not support triggering events" in e.message if e.message else False):
                 raise NotSupportedError(f"Input controller named {self.name} does not support triggering events")
             raise e
 
-    async def _stream_events(self):
+    async def _stream_events(self, metadata: ResourceRPCClientBase.Metadata):
         with self._stream_lock:
             if self._is_streaming:
                 return
@@ -112,6 +132,7 @@ class ControllerClient(Controller, ReconfigurableResourceRPCClientBase):
         if not self.callbacks:
             return
 
+        md = metadata.proto
         request = StreamEventsRequest(controller=self.name, events=[], extra=self._callback_extra)
         with self._lock:
             for control, callbacks in self.callbacks.items():
@@ -123,7 +144,7 @@ class ControllerClient(Controller, ReconfigurableResourceRPCClientBase):
                 request.events.append(event)
 
         try:
-            async with self.client.StreamEvents.open() as stream:
+            async with self.client.StreamEvents.open(metadata=md) as stream:
                 await stream.send_message(request, end=True)
                 self._send_connection_status(True)
                 reply: StreamEventsResponse
@@ -156,7 +177,18 @@ class ControllerClient(Controller, ReconfigurableResourceRPCClientBase):
         if all_callback is not None:
             all_callback(event)
 
-    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_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/input/input.py

@@ -10,7 +10,7 @@ from typing_extensions import Self
 from viam.components.component_base import ComponentBase
 from viam.errors import NotSupportedError
 from viam.proto.component.inputcontroller import Event as PBEvent
-from viam.resource.types import RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, Subtype
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
 
 
 class EventType(str, Enum):
@@ -135,17 +135,39 @@ class Controller(ComponentBase):
     Controller is a logical "container" more than an actual device
     Could be a single gamepad, or a collection of digitalInterrupts
     and analogReaders, a keyboard, etc.
+
+    ::
+
+        from viam.components.input import Control, Controller, EventType
+
+    For more information, see `Input Controller component <https://docs.viam.com/dev/reference/apis/components/input-controller/>`_.
     """
 
-    SUBTYPE: Final = Subtype(RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "input_controller")
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "input_controller"
+    )
 
     @abc.abstractmethod
     async def get_controls(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> List[Control]:
         """
         Returns a list of Controls provided by the Controller
 
+        ::
+
+            # Get the controller from the machine.
+            my_controller = Controller.from_robot(
+                robot=machine, "my_controller")
+
+            # Get the list of Controls provided by the controller.
+            controls = await my_controller.get_controls()
+
+            # Print the list of Controls provided by the controller.
+            print(f"Controls: {controls}")
+
         Returns:
             List[Control]: List of controls provided by the Controller
+
+        For more information, see `Input Controller component <https://docs.viam.com/dev/reference/apis/components/input-controller/#getcontrols>`_.
         """
         ...
 
@@ -157,8 +179,22 @@ class Controller(ComponentBase):
         Returns the most recent Event for each input
         (which should be the current state)
 
+        ::
+
+            # Get the controller from the machine.
+            my_controller = Controller.from_robot(
+                robot=machine, "my_controller")
+
+            # Get the most recent Event for each Control.
+            recent_events = await my_controller.get_events()
+
+            # Print out the most recent Event for each Control.
+            print(f"Recent Events: {recent_events}")
+
         Returns:
             Dict[Control, Event]: The most recent event for each input
+
+        For more information, see `Input Controller component <https://docs.viam.com/dev/reference/apis/components/input-controller/#getevents>`_.
         """
         ...
 
@@ -176,19 +212,86 @@ class Controller(ComponentBase):
         Register a function that will fire on given EventTypes for a given
         Control
 
+        ::
+
+            from viam.components.input import Control, EventType
+
+            # Define a function to handle pressing the Start Menu Button "BUTTON_START" on
+            # your controller, printing out the start time.
+            def print_start_time(event):
+                print(f"Start Menu Button was pressed at this time: {event.time}")
+
+
+            # Define a function that handles the controller.
+            async def handle_controller(controller):
+                # Get the list of Controls on the controller.
+                controls = await controller.get_controls()
+
+                # If the "BUTTON_START" Control is found, register the function
+                # print_start_time to fire when "BUTTON_START" has the event "ButtonPress"
+                # occur.
+                if Control.BUTTON_START in controls:
+                    controller.register_control_callback(
+                        Control.BUTTON_START, [EventType.BUTTON_PRESS], print_start_time)
+                else:
+                    print("Oops! Couldn't find the start button control! Is your "
+                        "controller connected?")
+                    exit()
+
+                while True:
+                    await asyncio.sleep(1.0)
+
+
+            async def main():
+                # ... < INSERT CONNECTION CODE FROM MACHINE'S CONNECT TAB >
+
+                # Get your controller from the machine.
+                my_controller = Controller.from_robot(
+                    robot=machine, "my_controller")
+
+                # Run the handleController function.
+                await handle_controller(my_controller)
+
+                # ... < INSERT ANY OTHER CODE FOR MAIN FUNCTION >
+
         Args:
             control (Control): The control to register the function for
             triggers (List[EventType]): The events that will
                 trigger the function
             function (ControlFunction): The function to run on
                 specific triggers
+
+        For more information, see `Input Controller component <https://docs.viam.com/dev/reference/apis/components/input-controller/#registercontrolcallback>`_.
         """
         ...
 
-    async def trigger_event(self, event: Event, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs):
+    async def trigger_event(
+        self,
+        event: Event,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> None:  # Explicitly return None for typechecking, as this is technically a NoReturn default implementation
         """Directly send an Event (such as a button press) from external code
 
+        ::
+
+            # Get your controller from the machine.
+            my_controller = Controller.from_robot(
+                robot=machine, "my_controller")
+
+            # Define a "Button is Pressed" event for the control BUTTON_START.
+            button_is_pressed_event = Event(
+                time(), EventType.BUTTON_PRESS, Control.BUTTON_START, 1.0)
+
+            # Trigger the event on your controller. Set this trigger to timeout if it has
+            # not completed in 7 seconds.
+            await my_controller.trigger_event(event=button_is_pressed_event, timeout=7.0)
+
         Args:
             event (Event): The event to trigger
+
+        For more information, see `Input Controller component <https://docs.viam.com/dev/reference/apis/components/input-controller/#triggerevent>`_.
         """
         raise NotSupportedError(f"Input controller named {self.name} does not support triggering events")

viam/components/input/service.py

@@ -6,8 +6,8 @@ from grpclib.server import Stream
 from h2.exceptions import StreamClosedError
 
 import viam
-from viam.errors import NotSupportedError, ResourceNotFoundError
-from viam.proto.common import DoCommandRequest, DoCommandResponse
+from viam.errors import NotSupportedError
+from viam.proto.common import DoCommandRequest, DoCommandResponse, GetGeometriesRequest, GetGeometriesResponse
 from viam.proto.component.inputcontroller import (
     GetControlsRequest,
     GetControlsResponse,
@@ -38,10 +38,7 @@ class InputControllerRPCService(InputControllerServiceBase, ResourceRPCServiceBa
         request = await stream.recv_message()
         assert request is not None
         name = request.controller
-        try:
-            controller = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        controller = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         controls = await controller.get_controls(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetControlsResponse(controls=[c.value for c in controls])
@@ -51,10 +48,7 @@ class InputControllerRPCService(InputControllerServiceBase, ResourceRPCServiceBa
         request = await stream.recv_message()
         assert request is not None
         name = request.controller
-        try:
-            controller = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        controller = self.get_resource(name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         events = await controller.get_events(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         pb_events = [e.proto for e in events.values()]
@@ -65,10 +59,7 @@ class InputControllerRPCService(InputControllerServiceBase, ResourceRPCServiceBa
         request = await stream.recv_message()
         assert request is not None
         name = request.controller
-        try:
-            controller = self.get_resource(name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        controller = self.get_resource(name)
 
         loop = asyncio.get_running_loop()
         # Using Pipes to send event data back to this function so it can be streamed to clients
@@ -154,13 +145,11 @@ class InputControllerRPCService(InputControllerServiceBase, ResourceRPCServiceBa
         assert request is not None
         name = request.controller
         timeout = stream.deadline.time_remaining() if stream.deadline else None
+        controller = self.get_resource(name)
         try:
-            controller = self.get_resource(name)
             pb_event = request.event
             event = Event.from_proto(pb_event)
             await controller.trigger_event(event, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
         except NotSupportedError as e:
             raise e.grpc_error
 
@@ -170,11 +159,17 @@ class InputControllerRPCService(InputControllerServiceBase, ResourceRPCServiceBa
     async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
         request = await stream.recv_message()
         assert request is not None
-        try:
-            controller = self.get_resource(request.name)
-        except ResourceNotFoundError as e:
-            raise e.grpc_error
+        controller = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
         result = await controller.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/motor/__init__.py

@@ -1,9 +1,4 @@
-import asyncio
-
-from viam.proto.component.motor import Status as MotorStatus
-from viam.proto.robot import Status
 from viam.resource.registry import Registry, ResourceRegistration
-from viam.utils import message_to_struct
 
 from .client import MotorClient
 from .motor import Motor
@@ -13,19 +8,4 @@ __all__ = [
     "Motor",
 ]
 
-
-async def create_status(component: Motor) -> Status:
-    ((is_powered, _), position, is_moving) = await asyncio.gather(
-        component.is_powered(),
-        component.get_position(),
-        component.is_moving(),
-    )
-    s = MotorStatus(
-        is_powered=is_powered,
-        position=position,
-        is_moving=is_moving,
-    )
-    return Status(name=Motor.get_resource_name(component.name), status=message_to_struct(s))
-
-
-Registry.register_subtype(ResourceRegistration(Motor, MotorRPCService, lambda name, channel: MotorClient(name, channel), create_status))
+Registry.register_api(ResourceRegistration(Motor, MotorRPCService, lambda name, channel: MotorClient(name, channel)))

viam/components/motor/client.py

@@ -1,8 +1,8 @@
-from typing import Any, Dict, Mapping, Optional, Tuple
+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
 from viam.proto.component.motor import (
     GetPositionRequest,
     GetPositionResponse,
@@ -17,10 +17,11 @@ from viam.proto.component.motor import (
     MotorServiceStub,
     ResetZeroPositionRequest,
     SetPowerRequest,
+    SetRPMRequest,
     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 .motor import Motor
 
@@ -41,11 +42,11 @@ class MotorClient(Motor, 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, power_pct=power, extra=dict_to_struct(extra))
-        await self.client.SetPower(request, timeout=timeout)
+        await self.client.SetPower(request, timeout=timeout, metadata=md)
 
     async def go_for(
         self,
@@ -54,11 +55,11 @@ class MotorClient(Motor, 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 = GoForRequest(name=self.name, rpm=rpm, revolutions=revolutions, extra=dict_to_struct(extra))
-        await self.client.GoFor(request, timeout=timeout)
+        await self.client.GoFor(request, timeout=timeout, metadata=md)
 
     async def go_to(
         self,
@@ -67,11 +68,23 @@ class MotorClient(Motor, 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 = GoToRequest(name=self.name, rpm=rpm, position_revolutions=position_revolutions, extra=dict_to_struct(extra))
-        await self.client.GoTo(request, timeout=timeout)
+        await self.client.GoTo(request, timeout=timeout, metadata=md)
+
+    async def set_rpm(
+        self,
+        rpm: float,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ):
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = SetRPMRequest(name=self.name, rpm=rpm, extra=dict_to_struct(extra))
+        await self.client.SetRPM(request, timeout=timeout, metadata=md)
 
     async def reset_zero_position(
         self,
@@ -79,22 +92,22 @@ class MotorClient(Motor, 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 = ResetZeroPositionRequest(name=self.name, offset=offset, extra=dict_to_struct(extra))
-        await self.client.ResetZeroPosition(request, timeout=timeout)
+        await self.client.ResetZeroPosition(request, timeout=timeout, metadata=md)
 
     async def get_position(
         self,
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> float:
-        if extra is None:
-            extra = {}
+        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 response.position
 
     async def get_properties(
@@ -102,11 +115,11 @@ class MotorClient(Motor, ReconfigurableResourceRPCClientBase):
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> Motor.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 Motor.Properties(position_reporting=response.position_reporting)
 
     async def stop(
@@ -114,32 +127,42 @@ class MotorClient(Motor, 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 = 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_powered(
         self,
         *,
         extra: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
+        **kwargs,
     ) -> Tuple[bool, float]:
-        if extra is None:
-            extra = {}
+        md = kwargs.get("metadata", self.Metadata()).proto
         request = IsPoweredRequest(name=self.name, extra=dict_to_struct(extra))
-        response: IsPoweredResponse = await self.client.IsPowered(request, timeout=timeout)
+        response: IsPoweredResponse = await self.client.IsPowered(request, timeout=timeout, metadata=md)
         return response.is_on, response.power_pct
 
-    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_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)