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

viam/app/ml_training_client.py

@@ -46,11 +46,9 @@ class MLTrainingClient:
         async def main():
 
             # Make a ViamClient
-            viam_client = await connect()
-            # Instantiate an MLTrainingClient to run ML training client API methods on
-            ml_training_client = viam_client.ml_training_client
-
-            viam_client.close()
+            async with await connect() as viam_client:
+                # Instantiate an MLTrainingClient to run ML training client API methods on
+                ml_training_client = viam_client.ml_training_client
 
         if __name__ == '__main__':
             asyncio.run(main())

viam/app/provisioning_client.py

@@ -41,11 +41,9 @@ class ProvisioningClient:
         async def main():
 
             # Make a ViamClient
-            viam_client = await connect()
-            # Instantiate a ProvisioningClient to run provisioning client API methods on
-            provisioning_client = viam_client.provisioning_client
-
-            viam_client.close()
+            async with await connect() as viam_client:
+                # Instantiate a ProvisioningClient to run provisioning client API methods on
+                provisioning_client = viam_client.provisioning_client
 
         if __name__ == '__main__':
             asyncio.run(main())

viam/app/viam_client.py

@@ -1,4 +1,5 @@
-from typing import Mapping, Optional
+import os
+from typing import Any, Mapping, Optional
 
 from grpclib.client import Channel
 from typing_extensions import Self
@@ -10,7 +11,7 @@ from viam.app.data_client import DataClient
 from viam.app.ml_training_client import MLTrainingClient
 from viam.app.provisioning_client import ProvisioningClient
 from viam.robot.client import RobotClient
-from viam.rpc.dial import DialOptions, _dial_app, _get_access_token
+from viam.rpc.dial import Credentials, DialOptions, _dial_app, _get_access_token
 
 LOGGER = logging.getLogger(__name__)
 
@@ -19,19 +20,51 @@ class ViamClient:
     """gRPC client for all communication and interaction with app.
 
     `ViamClient` class for creating and managing specialized client instances.
-    There is currently 1 way to instantiate a `ViamClient` object::
+    There are currently 2 ways to instantiate a `ViamClient` object::
 
         ViamClient.create_from_dial_options(...)
+        ViamClient.create_from_env_vars()
     """
 
+    @classmethod
+    async def create_from_env_vars(cls, dial_options: Optional[DialOptions] = None, app_url: Optional[str] = None) -> Self:
+        """Create `ViamClient` using credentials set in the environment as `VIAM_API_KEY` and `VIAM_API_KEY_ID`.
+
+        ::
+
+            client = await ViamClient.create_from_env_vars()
+
+        Args:
+            dial_options (Optional[viam.rpc.dial.DialOptions]): Options for authorization and connection to app.
+                If not provided, default options will be selected. Note that `creds` and `auth_entity`
+                fields will be overwritten by the values set by a module.
+            app_url: (Optional[str]): URL of app. Uses app.viam.com if not specified.
+
+        Raises:
+            ValueError: If there are no env vars set by the module, or if they are set improperly
+
+        """
+        dial_options = dial_options if dial_options else DialOptions()
+        api_key = os.environ.get("VIAM_API_KEY")
+        if api_key is None:
+            raise ValueError("api key cannot be None")
+        api_key_id = os.environ.get("VIAM_API_KEY_ID")
+        if api_key_id is None:
+            raise ValueError("api key ID cannot be None")
+        credentials = Credentials(type="api-key", payload=api_key)
+        dial_options.credentials = credentials
+        dial_options.auth_entity = api_key_id
+
+        return await cls.create_from_dial_options(dial_options, app_url)
+
     @classmethod
     async def create_from_dial_options(cls, dial_options: DialOptions, app_url: Optional[str] = None) -> Self:
-        """Create `ViamClient` that establishes a connection to the Viam app.
+        """Create `ViamClient` that establishes a connection to Viam.
 
         ::
 
             dial_options = DialOptions.with_api_key("<API-KEY>", "<API-KEY-ID>")
-            ViamClient.create_from_dial_options(dial_options)
+            client = await ViamClient.create_from_dial_options(dial_options)
 
         Args:
             dial_options (viam.rpc.dial.DialOptions): Required information for authorization and connection to app.
@@ -53,9 +86,6 @@ class ViamClient:
 
         self = cls()
         self._dial_options = dial_options
-        self._location_id = None
-        if dial_options.credentials.type == "robot-location-secret":
-            self._location_id = dial_options.auth_entity.split(".")[1]
         if app_url is None:
             app_url = "app.viam.com"
         self._channel = await _dial_app(app_url)
@@ -66,7 +96,6 @@ class ViamClient:
     _channel: Channel
     _metadata: Mapping[str, str]
     _closed: bool = False
-    _location_id: Optional[str]
     _dial_options: DialOptions
 
     @property
@@ -108,7 +137,7 @@ class ViamClient:
                 # Instantiate an AppClient called "fleet" to run fleet management API methods on
                 fleet = viam_client.app_client
         """
-        return AppClient(self._channel, self._metadata, self._location_id)
+        return AppClient(self._channel, self._metadata)
 
     @property
     def ml_training_client(self) -> MLTrainingClient:
@@ -174,7 +203,25 @@ class ViamClient:
         """
         return ProvisioningClient(self._channel, self._metadata)
 
-    def close(self):
+    async def __aenter__(self) -> "ViamClient":
+        """A ViamClient can act as an asynchronous context manager. It will do nothing special when
+        the context is entered.
+        """
+        return self
+
+    async def __aexit__(self, exc_type: Optional[type], exc_value: Optional[BaseException], traceback: Optional[Any]) -> None:
+        """A ViamClient can act as an asynchronous context manager. It will close itself when
+        the context is exited.
+
+        ::
+
+            async with ViamClient.create_from_dial_options(...) as client:
+                await do_something_with(client)
+            # client is closed here
+        """
+        self.close()
+
+    def close(self) -> None:
         """Close opened channels used for the various service stubs initialized."""
         if self._closed:
             LOGGER.debug("ViamClient is already closed.")

viam/components/arm/arm.py

@@ -194,7 +194,7 @@ class Arm(ComponentBase):
 
     @abc.abstractmethod
     async def get_kinematics(
-        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
     ) -> Tuple[KinematicsFileFormat.ValueType, bytes]:
         """
         Get the kinematics information associated with the arm.

viam/components/arm/service.py

@@ -109,7 +109,7 @@ class ArmRPCService(UnimplementedArmServiceBase, ResourceRPCServiceBase[Arm]):
         assert request is not None
         arm = self.get_resource(request.name)
         timeout = stream.deadline.time_remaining() if stream.deadline else None
-        format, kinematics_data = await arm.get_kinematics(extra=struct_to_dict(request.extra), timeout=timeout)
+        format, kinematics_data = await arm.get_kinematics(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
         response = GetKinematicsResponse(format=format, kinematics_data=kinematics_data)
         await stream.send_message(response)
 

viam/components/audio_in/__init__.py

@@ -0,0 +1,24 @@
+from viam.media.audio import AudioCodec
+from viam.proto.common import AudioInfo
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .audio_in import AudioIn
+from .client import AudioInClient
+from .service import AudioInRPCService
+
+AudioResponse = AudioIn.AudioResponse
+
+__all__ = [
+    "AudioIn",
+    "AudioResponse",
+    "AudioInfo",
+    "AudioCodec",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        AudioIn,
+        AudioInRPCService,
+        lambda name, channel: AudioInClient(name, channel),
+    )
+)

viam/components/audio_in/audio_in.py

@@ -0,0 +1,74 @@
+import abc
+import sys
+from typing import Final, Optional
+
+from viam.proto.common import GetPropertiesResponse
+from viam.proto.component.audioin import GetAudioResponse
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+from viam.streams import Stream
+
+from ..component_base import ComponentBase
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+class AudioIn(ComponentBase):
+    """AudioIn represents a component that can capture audio.
+
+    This acts as an abstract base class for any drivers representing specific
+    audio input implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "audio_in"
+    )
+
+    Properties: "TypeAlias" = GetPropertiesResponse
+    AudioResponse: "TypeAlias" = GetAudioResponse
+    AudioStream = Stream[AudioResponse]
+
+    @abc.abstractmethod
+    async def get_audio(
+        self, codec: str, duration_seconds: float, previous_timestamp_ns: int, *, timeout: Optional[float] = None, **kwargs
+    ) -> AudioStream:
+        """
+        Get a stream of audio from the device
+
+        ::
+
+            my_audio_in = AudioIn.from_robot(robot=machine, name="my_audio_in")
+
+            stream = await my_audio_in.get_audio(
+                codec=AudioCodec.PCM16,
+                duration_seconds=10.0,
+                previous_timestamp_ns=0
+            )
+
+        Args:
+            codec (str): The desired codec of the returned audio data
+            duration_seconds (float): duration of the stream. 0 = indefinite stream
+            previous_timestamp_ns (int): starting timestamp in nanoseconds for recording continuity.
+            Set to 0 to begin recording from the current time.
+        Returns:
+            AudioStream: stream of audio chunks.
+        ...
+        """
+
+    @abc.abstractmethod
+    async def get_properties(self, *, timeout: Optional[float] = None, **kwargs) -> Properties:
+        """
+        Get the audio device's properties
+
+        ::
+
+            my_audio_in = AudioIn.from_robot(robot=machine, name="my_audio_in")
+            properties = await my_audio_in.get_properties()
+
+        Returns:
+            Properties: The properties of the audio in device.
+        ...
+        """

viam/components/audio_in/client.py

@@ -0,0 +1,76 @@
+import uuid
+from typing import Any, Dict, List, Mapping, Optional
+
+from grpclib.client import Channel
+from grpclib.client import Stream as ClientStream
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetPropertiesRequest
+from viam.proto.component.audioin import AudioInServiceStub, GetAudioRequest, GetAudioResponse
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.streams import StreamWithIterator
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from .audio_in import AudioIn
+
+
+class AudioInClient(AudioIn, ReconfigurableResourceRPCClientBase):
+    def __init__(self, name: str, channel: Channel) -> None:
+        self.channel = channel
+        self.client = AudioInServiceStub(channel)
+        super().__init__(name)
+
+    async def get_audio(
+        self,
+        codec: str,
+        duration_seconds: float,
+        previous_timestamp_ns: int,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ):
+        request = GetAudioRequest(
+            name=self.name,
+            codec=codec,
+            duration_seconds=duration_seconds,
+            previous_timestamp_nanoseconds=previous_timestamp_ns,
+            request_id=str(uuid.uuid4()),
+            extra=dict_to_struct(extra),
+        )
+
+        async def read():
+            md = kwargs.get("metadata", self.Metadata()).proto
+            audio_stream: ClientStream[GetAudioRequest, GetAudioResponse]
+            async with self.client.GetAudio.open(metadata=md) as audio_stream:
+                try:
+                    await audio_stream.send_message(request, end=True)
+                    async for response in audio_stream:
+                        yield response
+                except Exception as e:
+                    raise (e)
+
+        return StreamWithIterator(read())
+
+    async def get_properties(
+        self,
+        *,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> AudioIn.Properties:
+        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, 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/audio_in/service.py

@@ -0,0 +1,83 @@
+from grpclib.server import Stream
+from h2.exceptions import StreamClosedError
+
+from viam.logging import getLogger
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+)
+from viam.proto.component.audioin import AudioInServiceBase, GetAudioRequest, GetAudioResponse
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .audio_in import AudioIn
+
+LOGGER = getLogger(__name__)
+
+
+class AudioInRPCService(AudioInServiceBase, ResourceRPCServiceBase[AudioIn]):
+    """
+    gRPC Service for a generic audio in.
+    """
+
+    RESOURCE_TYPE = AudioIn
+
+    async def GetAudio(self, stream: Stream[GetAudioRequest, GetAudioResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        audio_in = self.get_resource(name)
+        audio_stream = await audio_in.get_audio(
+            codec=request.codec,
+            duration_seconds=request.duration_seconds,
+            previous_timestamp_ns=request.previous_timestamp_nanoseconds,
+            metadata=stream.metadata,
+        )
+        async for response in audio_stream:
+            try:
+                response.request_id = request.request_id
+                await stream.send_message(response)
+            except StreamClosedError:
+                return
+            except Exception as e:
+                LOGGER.error(e)
+                return
+
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        audio_in = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await audio_in.get_properties(
+            timeout=timeout,
+            metadata=stream.metadata,
+        )
+        await stream.send_message(properties)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        audio_in = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await audio_in.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/audio_out/__init__.py

@@ -0,0 +1,21 @@
+from viam.media.audio import AudioCodec
+from viam.proto.common import AudioInfo
+from viam.resource.registry import Registry, ResourceRegistration
+
+from .audio_out import AudioOut
+from .client import AudioOutClient
+from .service import AudioOutRPCService
+
+__all__ = [
+    "AudioOut",
+    "AudioInfo",
+    "AudioCodec",
+]
+
+Registry.register_api(
+    ResourceRegistration(
+        AudioOut,
+        AudioOutRPCService,
+        lambda name, channel: AudioOutClient(name, channel),
+    )
+)

viam/components/audio_out/audio_out.py

@@ -0,0 +1,72 @@
+import abc
+import sys
+from typing import Any, Dict, Final, Optional
+
+from viam.proto.common import GetPropertiesResponse
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT
+
+from ..component_base import ComponentBase
+from . import AudioInfo
+
+if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+else:
+    from typing_extensions import TypeAlias
+
+
+class AudioOut(ComponentBase):
+    """AudioOut represents a component that can play audio.
+
+    This acts as an abstract base class for any drivers representing specific
+    audio output implementations. This cannot be used on its own. If the ``__init__()`` function is
+    overridden, it must call the ``super().__init__()`` function.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_COMPONENT, "audio_out"
+    )
+
+    Properties: "TypeAlias" = GetPropertiesResponse
+
+    @abc.abstractmethod
+    async def play(
+        self,
+        data: bytes,
+        info: Optional[AudioInfo] = None,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> None:
+        """
+        Play the given audio data.
+
+        ::
+
+            my_audio_out = AudioOut.from_robot(robot=machine, name="my_audio_out")
+
+            # With audio info
+            audio_info = AudioInfo(codec=AudioCodec.PCM16, sample_rate_hz=44100, num_channels=2)
+            await my_audio_out.play(audio_data, audio_info)
+
+            # Without audio info (when codec encodes information within audio_data)
+            await my_audio_out.play(audio_data)
+
+        Args:
+            data: audio bytes to play
+            info: (optional) information about the audio data such as codec, sample rate, and channel count
+        """
+
+    @abc.abstractmethod
+    async def get_properties(self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs) -> Properties:
+        """
+        Get the audio output device's properties.
+
+        ::
+
+            my_audio_out = AudioOut.from_robot(robot=machine, name="my_audio_out")
+            properties = await my_audio_out.get_properties()
+
+        Returns:
+            Properties: The properties of the audio output device
+        """

viam/components/audio_out/client.py

@@ -0,0 +1,67 @@
+from typing import Any, Dict, List, Mapping, Optional
+
+from grpclib.client import Channel
+
+from viam.proto.common import DoCommandRequest, DoCommandResponse, Geometry, GetPropertiesRequest, GetPropertiesResponse
+from viam.proto.component.audioout import AudioOutServiceStub, PlayRequest
+from viam.resource.rpc_client_base import ReconfigurableResourceRPCClientBase
+from viam.utils import ValueTypes, dict_to_struct, get_geometries, struct_to_dict
+
+from .audio_out import AudioInfo, AudioOut
+
+
+class AudioOutClient(AudioOut, ReconfigurableResourceRPCClientBase):
+    """gRPC client for AudioOut component."""
+
+    def __init__(self, name: str, channel: Channel) -> None:
+        self.channel = channel
+        self.client = AudioOutServiceStub(channel)
+        super().__init__(name)
+
+    async def play(
+        self,
+        data: bytes,
+        info: Optional[AudioInfo] = None,
+        *,
+        extra: Optional[Dict[str, Any]] = None,
+        timeout: Optional[float] = None,
+        **kwargs,
+    ) -> None:
+        if extra is None:
+            extra = {}
+
+        md = kwargs.get("metadata", self.Metadata()).proto
+        request = PlayRequest(
+            name=self.name,
+            audio_data=data,
+            audio_info=info,
+            extra=dict_to_struct(extra),
+        )
+        await self.client.Play(request, timeout=timeout, metadata=md)
+
+    async def get_properties(
+        self, *, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, **kwargs
+    ) -> AudioOut.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, metadata=md)
+        return response
+
+    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)
+
+    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/audio_out/service.py

@@ -0,0 +1,63 @@
+from grpclib.server import Stream
+
+from viam.proto.common import (
+    DoCommandRequest,
+    DoCommandResponse,
+    GetGeometriesRequest,
+    GetGeometriesResponse,
+    GetPropertiesRequest,
+    GetPropertiesResponse,
+)
+from viam.proto.component.audioout import (
+    AudioOutServiceBase,
+    PlayRequest,
+    PlayResponse,
+)
+from viam.resource.rpc_service_base import ResourceRPCServiceBase
+from viam.utils import dict_to_struct, struct_to_dict
+
+from .audio_out import AudioOut
+
+
+class AudioOutRPCService(AudioOutServiceBase, ResourceRPCServiceBase[AudioOut]):
+    """gRPC service for AudioOut component."""
+
+    RESOURCE_TYPE = AudioOut
+
+    async def Play(self, stream: Stream[PlayRequest, PlayResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        audio_out = self.get_resource(name)
+        # Check if audio_info was provided in the request
+        audio_info = request.audio_info if request.HasField("audio_info") else None
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        await audio_out.play(request.audio_data, audio_info, extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(PlayResponse())
+
+    async def GetProperties(self, stream: Stream[GetPropertiesRequest, GetPropertiesResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        name = request.name
+        audio_out = self.get_resource(name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        properties = await audio_out.get_properties(extra=struct_to_dict(request.extra), timeout=timeout, metadata=stream.metadata)
+        await stream.send_message(properties)
+
+    async def DoCommand(self, stream: Stream[DoCommandRequest, DoCommandResponse]) -> None:
+        request = await stream.recv_message()
+        assert request is not None
+        audio_out = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        result = await audio_out.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
+        audio_out = self.get_resource(request.name)
+        timeout = stream.deadline.time_remaining() if stream.deadline else None
+        geometries = await audio_out.get_geometries(extra=struct_to_dict(request.extra), timeout=timeout)
+        response = GetGeometriesResponse(geometries=geometries)
+        await stream.send_message(response)

viam/components/base/base.py

@@ -126,7 +126,7 @@ class Base(ComponentBase):
             # Make your wheeled base move forward. Set linear power to 75%.
             print("move forward")
             await my_base.set_power(
-                linear=Vector3(x=0, y=-.75, z=0),
+                linear=Vector3(x=0, y=.75, z=0),
                 angular=Vector3(x=0, y=0, z=0))
 
             # Make your wheeled base move backward. Set linear power to -100%.