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

viam/services/worldstatestore/worldstatestore.py

@@ -0,0 +1,90 @@
+import abc
+from typing import Any, AsyncGenerator, Final, List, Mapping, Optional
+
+from viam.proto.common import Transform
+from viam.proto.service.worldstatestore import (
+    StreamTransformChangesResponse,
+)
+from viam.resource.types import API, RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE
+
+from ..service_base import ServiceBase
+
+
+class WorldStateStore(ServiceBase):
+    """WorldStateStore is a Viam service that manages world state transforms.
+
+    The WorldStateStore service provides functionality to store, retrieve, and stream
+    changes to world state transforms, which represent the pose of objects in different
+    reference frames. This functionality can be used to create custom visualizations of the world state.
+
+    For more information, see `WorldStateStore service <https://docs.viam.com/dev/reference/apis/services/world-state-store/>`_.
+    """
+
+    API: Final = API(  # pyright: ignore [reportIncompatibleVariableOverride]
+        RESOURCE_NAMESPACE_RDK, RESOURCE_TYPE_SERVICE, "world_state_store"
+    )
+
+    @abc.abstractmethod
+    async def list_uuids(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> List[bytes]:
+        """List all world state transform UUIDs.
+
+        ::
+
+            worldstatestore = WorldStateStoreClient.from_robot(robot=machine, name="builtin")
+
+            uuids = await worldstatestore.list_uuids()
+
+        Returns:
+            List[bytes]: A list of transform UUIDs
+        """
+        ...
+
+    @abc.abstractmethod
+    async def get_transform(
+        self,
+        uuid: bytes,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> Transform:
+        """Get a world state transform by UUID.
+
+        ::
+
+            worldstatestore = WorldStateStoreClient.from_robot(robot=machine, name="builtin")
+
+            transform = await worldstatestore.get_transform(uuid=b"some-uuid")
+
+        Args:
+            uuid (bytes): The UUID of the transform to retrieve
+
+        Returns:
+            Transform: The requested transform
+        """
+        ...
+
+    @abc.abstractmethod
+    async def stream_transform_changes(
+        self,
+        *,
+        extra: Optional[Mapping[str, Any]] = None,
+        timeout: Optional[float] = None,
+    ) -> AsyncGenerator[StreamTransformChangesResponse, None]:
+        """Stream changes to world state transforms.
+
+        ::
+
+            worldstatestore = WorldStateStoreClient.from_robot(robot=machine, name="builtin")
+
+            async for change in worldstatestore.stream_transform_changes():
+                print(f"Transform {change.transform.uuid} {change.change_type}")
+
+        Returns:
+            AsyncGenerator[StreamTransformChangesResponse, None]: A stream of transform changes
+        """
+        ...

viam/sessions_client.py

@@ -1,9 +1,14 @@
 import asyncio
+import importlib
+import pkgutil
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import asynccontextmanager
 from copy import deepcopy
 from datetime import timedelta
 from enum import IntEnum
 from threading import Lock, Thread
-from typing import Optional
+from typing import MutableMapping, Optional
 
 from grpclib import Status
 from grpclib.client import Channel
@@ -12,26 +17,13 @@ from grpclib.exceptions import GRPCError, StreamTerminatedError
 from grpclib.metadata import _MetadataLike
 
 from viam import logging
+from viam.gen.common.v1.common_pb2 import safety_heartbeat_monitored
 from viam.proto.robot import RobotServiceStub, SendSessionHeartbeatRequest, StartSessionRequest, StartSessionResponse
 from viam.rpc.dial import DialOptions, dial
 
 LOGGER = logging.getLogger(__name__)
 SESSION_METADATA_KEY = "viam-sid"
 
-EXEMPT_METADATA_METHODS = frozenset(
-    [
-        "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
-        "/proto.rpc.webrtc.v1.SignalingService/Call",
-        "/proto.rpc.webrtc.v1.SignalingService/CallUpdate",
-        "/proto.rpc.webrtc.v1.SignalingService/OptionalWebRTCConfig",
-        "/proto.rpc.v1.AuthService/Authenticate",
-        "/viam.robot.v1.RobotService/ResourceNames",
-        "/viam.robot.v1.RobotService/ResourceRPCSubtypes",
-        "/viam.robot.v1.RobotService/StartSession",
-        "/viam.robot.v1.RobotService/SendSessionHeartbeat",
-    ]
-)
-
 
 class _SupportedState(IntEnum):
     UNKNOWN = 0
@@ -47,7 +39,8 @@ class SessionsClient:
 
     channel: Channel
     client: RobotServiceStub
-    _address: str
+    _address: str  # direct dial address, when using webRTC this is the local socket rather than a robot address
+    _robot_address: Optional[str]  # the actual machine address on app.viam.com. important for creating a sessions client on Windows
     _dial_options: DialOptions
     _disabled: bool
     _lock: Lock
@@ -55,19 +48,33 @@ class SessionsClient:
     _heartbeat_interval: Optional[timedelta]
     _supported: _SupportedState
     _thread: Optional[Thread]
-
-    def __init__(self, channel: Channel, direct_dial_address: str, dial_options: Optional[DialOptions], *, disabled: bool = False):
+    _pool: ThreadPoolExecutor
+
+    _HEARTBEAT_MONITORED_METHODS: MutableMapping[str, bool] = {}
+
+    def __init__(
+        self,
+        channel: Channel,
+        direct_dial_address: str,
+        dial_options: Optional[DialOptions],
+        *,
+        disabled: bool = False,
+        robot_addr: Optional[str] = None,
+    ):
         self.channel = channel
         self.client = RobotServiceStub(channel)
         self._address = direct_dial_address
+        self._robot_address = robot_addr
         self._disabled = disabled
         self._dial_options = deepcopy(dial_options) if dial_options is not None else DialOptions()
-        self._dial_options.disable_webrtc = True
+        if sys.platform != "win32" and sys.platform != "cygwin":
+            self._dial_options.disable_webrtc = True
         self._lock = Lock()
         self._current_id = ""
         self._heartbeat_interval = None
         self._supported = _SupportedState.UNKNOWN
         self._thread = None
+        self._pool = ThreadPoolExecutor()
 
         listen(self.channel, SendRequest, self._send_request)
         listen(self.channel, RecvTrailingMetadata, self._recv_trailers)
@@ -92,7 +99,7 @@ class SessionsClient:
         if self._disabled:
             return
 
-        if event.method_name in EXEMPT_METADATA_METHODS:
+        if not self._is_safety_heartbeat_monitored(event.method_name):
             return
 
         event.metadata.update(await self.metadata)
@@ -102,39 +109,45 @@ class SessionsClient:
             LOGGER.debug("Session expired")
             self.reset()
 
+    @asynccontextmanager
+    async def _acquire_lock_async(self):
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(self._pool, self._lock.acquire)
+        try:
+            yield
+        finally:
+            self._lock.release()
+
     @property
     async def metadata(self) -> _MetadataLike:
-        with self._lock:
+        async with self._acquire_lock_async():
             if self._disabled or self._supported != _SupportedState.UNKNOWN:
                 return self._metadata
 
-        request = StartSessionRequest(resume=self._current_id)
-        try:
-            response: StartSessionResponse = await self.client.StartSession(request)
-        except GRPCError as error:
-            if error.status == Status.UNIMPLEMENTED:
-                with self._lock:
+            request = StartSessionRequest(resume=self._current_id)
+            try:
+                response: StartSessionResponse = await self.client.StartSession(request)
+            except GRPCError as error:
+                if error.status == Status.UNIMPLEMENTED:
                     self._reset()
                     self._supported = _SupportedState.FALSE
                     return self._metadata
-            else:
-                raise
+                else:
+                    raise
 
-        if response is None:
-            raise GRPCError(status=Status.INTERNAL, message="Expected response to start session")
+            if response is None:
+                raise GRPCError(status=Status.INTERNAL, message="Expected response to start session")
 
-        if response.heartbeat_window is None:
-            raise GRPCError(status=Status.INTERNAL, message="Expected heartbeat window in response to start session")
+            if response.heartbeat_window is None:
+                raise GRPCError(status=Status.INTERNAL, message="Expected heartbeat window in response to start session")
 
-        with self._lock:
             self._supported = _SupportedState.TRUE
             self._heartbeat_interval = response.heartbeat_window.ToTimedelta()
             self._current_id = response.id
 
-        # tick once to ensure heartbeats are supported
-        await self._heartbeat_tick(self.client)
+            # tick once to ensure heartbeats are supported
+            await self._heartbeat_tick(self.client)
 
-        with self._lock:
             if self._thread is not None:
                 self._reset()
             if self._supported == _SupportedState.TRUE:
@@ -153,28 +166,38 @@ class SessionsClient:
             return self._metadata
 
     async def _heartbeat_tick(self, client: RobotServiceStub):
-        with self._lock:
-            if not self._current_id:
-                LOGGER.debug("Failed to send heartbeat, session client reset")
-                return
-            request = SendSessionHeartbeatRequest(id=self._current_id)
+        if not self._current_id:
+            LOGGER.debug("Failed to send heartbeat, session client reset")
+            return
+        request = SendSessionHeartbeatRequest(id=self._current_id)
 
         try:
             await client.SendSessionHeartbeat(request)
         except (GRPCError, StreamTerminatedError):
             LOGGER.debug("Heartbeat terminated", exc_info=True)
-            self.reset()
+            self._reset()
         else:
             LOGGER.debug("Sent heartbeat successfully")
 
+    def _get_local_addr(self) -> str:
+        if sys.platform != "win32" and sys.platform != "cygwin":
+            # if we're not on windows, we want the direct dial address
+            return self._address
+
+        # return `robot_address` if it exists, otherwise fallback
+        # when using TCP (i.e., on Windows), we need to create a connection to the actual
+        # robot address for a sessions client to maintain connectivity successfully
+        return self._robot_address if self._robot_address is not None else self._address
+
     async def _heartbeat_process(self, wait: float):
-        channel = await dial(address=self._address, options=self._dial_options)
+        addr = self._get_local_addr()
+        channel = await dial(address=addr, options=self._dial_options)
         client = RobotServiceStub(channel.channel)
         while True:
-            with self._lock:
+            async with self._acquire_lock_async():
                 if self._supported != _SupportedState.TRUE:
                     return
-            await self._heartbeat_tick(client)
+                await self._heartbeat_tick(client)
             await asyncio.sleep(wait)
 
     @property
@@ -183,3 +206,49 @@ class SessionsClient:
             return {SESSION_METADATA_KEY: self._current_id}
 
         return {}
+
+    def _is_safety_heartbeat_monitored(self, method: str) -> bool:
+        if method in self._HEARTBEAT_MONITORED_METHODS:
+            return self._HEARTBEAT_MONITORED_METHODS[method]
+
+        parts = method.split("/")
+        if len(parts) != 3:
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        service_path = parts[1]
+        method_name = parts[2]
+
+        parts = service_path.split(".")
+        if len(parts) < 5:
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        if parts[0] != "viam":
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        resource_type = parts[1]
+        resource_subtype = parts[2]
+        version = parts[3]
+        service_name = parts[4]
+        try:
+            module = importlib.import_module(f"viam.gen.{resource_type}.{resource_subtype}.{version}")
+            submods = pkgutil.iter_modules(module.__path__)
+            for mod in submods:
+                if "_pb2" in mod.name:
+                    submod = getattr(module, mod.name)
+                    DESCRIPTOR = getattr(submod, "DESCRIPTOR")
+                    for service in DESCRIPTOR.services_by_name.values():
+                        if service.name == service_name:
+                            for method_actual in service.methods:
+                                if method_actual.name == method_name:
+                                    options = method_actual.GetOptions()
+                                    if options.HasExtension(safety_heartbeat_monitored):
+                                        is_monitored = options.Extensions[safety_heartbeat_monitored]
+                                        self._HEARTBEAT_MONITORED_METHODS[method] = is_monitored
+                                        return is_monitored
+                                    self._HEARTBEAT_MONITORED_METHODS[method] = False
+                                    return False
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False
+        except Exception:
+            self._HEARTBEAT_MONITORED_METHODS[method] = False
+            return False

viam/streams.py

@@ -11,8 +11,7 @@ StreamType = TypeVar("StreamType", covariant=True)
 
 
 class Stream(Protocol[StreamType]):
-    async def next(self) -> StreamType:
-        ...
+    async def next(self) -> StreamType: ...
 
     def __aiter__(self) -> AsyncIterator:
         return self
@@ -22,13 +21,11 @@ class Stream(Protocol[StreamType]):
 
 
 class StreamReader(Protocol[StreamType]):
-    async def read(self) -> StreamType:
-        ...
+    async def read(self) -> StreamType: ...
 
 
 class StreamSource(Protocol[StreamType]):
-    async def stream(self) -> Stream[StreamType]:
-        ...
+    async def stream(self) -> Stream[StreamType]: ...
 
 
 class StreamWithIterator(Stream[StreamType]):

viam/utils.py

@@ -4,7 +4,7 @@ import functools
 import sys
 import threading
 from datetime import datetime
-from typing import Any, Dict, List, Mapping, Optional, SupportsBytes, SupportsFloat, Type, TypeVar, Union
+from typing import Any, Callable, Dict, List, Mapping, Optional, SupportsBytes, SupportsFloat, Type, TypeVar, Union
 
 from google.protobuf.json_format import MessageToDict, ParseDict
 from google.protobuf.message import Message
@@ -15,7 +15,8 @@ from viam.proto.app.data import CaptureInterval, Filter, TagsFilter
 from viam.proto.common import Geometry, GeoPoint, GetGeometriesRequest, GetGeometriesResponse, Orientation, ResourceName, Vector3
 from viam.resource.base import ResourceBase
 from viam.resource.registry import Registry
-from viam.resource.types import Subtype, SupportsGetGeometries
+from viam.resource.rpc_client_base import ResourceRPCClientBase
+from viam.resource.types import API, SupportsGetGeometries
 
 if sys.version_info >= (3, 9):
     from collections.abc import Callable
@@ -103,14 +104,10 @@ def resource_names_for_resource(resource: ResourceBase) -> List[ResourceName]:
     rns: List[ResourceName] = []
 
     for klass in resource.__class__.mro():
-        for registration in Registry.REGISTERED_SUBTYPES().values():
+        for registration in Registry.REGISTERED_APIS().values():
             if klass is registration.resource_type:
-                subtype: Subtype = registration.resource_type.SUBTYPE
-                rns.append(
-                    ResourceName(
-                        namespace=subtype.namespace, type=subtype.resource_type, subtype=subtype.resource_subtype, name=resource.name
-                    )
-                )
+                api: API = registration.resource_type.API
+                rns.append(ResourceName(namespace=api.namespace, type=api.resource_type, subtype=api.resource_subtype, name=resource.name))
     return rns
 
 
@@ -134,7 +131,7 @@ def struct_to_message(struct: Struct, message_type: Type[_T]) -> _T:
     return ParseDict(dct, message_type())
 
 
-def dict_to_struct(obj: Mapping[str, ValueTypes]) -> Struct:
+def dict_to_struct(obj: Optional[Mapping[str, ValueTypes]]) -> Struct:
     def _convert(v: ValueTypes) -> Any:
         if isinstance(v, bool):
             return v
@@ -148,6 +145,8 @@ def dict_to_struct(obj: Mapping[str, ValueTypes]) -> Struct:
             return {k: _convert(vv) for (k, vv) in v.items()}
         return v
 
+    if obj is None:
+        obj = {}
     struct = Struct()
     struct.update({k: _convert(v) for (k, v) in obj.items()})
     return struct
@@ -166,12 +165,15 @@ def datetime_to_timestamp(dt: Optional[datetime]) -> Optional[Timestamp]:
 
 
 async def get_geometries(
-    client: SupportsGetGeometries, name: str, extra: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None
+    client: SupportsGetGeometries,
+    name: str,
+    extra: Optional[Dict[str, Any]] = None,
+    timeout: Optional[float] = None,
+    metadata: ResourceRPCClientBase.Metadata = ResourceRPCClientBase.Metadata(),
 ) -> List[Geometry]:
-    if extra is None:
-        extra = {}
+    md = metadata.proto
     request = GetGeometriesRequest(name=name, extra=dict_to_struct(extra))
-    response: GetGeometriesResponse = await client.GetGeometries(request, timeout=timeout)
+    response: GetGeometriesResponse = await client.GetGeometries(request, timeout=timeout, metadata=md)
     return [geometry for geometry in response.geometries]
 
 
@@ -333,3 +335,31 @@ def create_filter(
         bbox_labels=bbox_labels,
         dataset_id=dataset_id if dataset_id else "",
     )
+
+
+def _alias_param(param_name: str, param_alias: str) -> Callable:
+    """
+    Decorator for aliasing a param in a function. Intended for providing backwards compatibility on params with name changes.
+
+    Args:
+        param_name: name of param in function to alias
+        param_alias: alias that can be used for this param
+    Returns:
+        The input function, plus param alias.
+    """
+
+    def decorator(func: Callable):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            alias_param_value = kwargs.get(param_alias)
+            if alias_param_value:
+                # Only use alias value if param is not given.
+                if not kwargs.get(param_name):
+                    kwargs[param_name] = alias_param_value
+                del kwargs[param_alias]
+            result = func(*args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator

viam/version_metadata.py

@@ -0,0 +1,4 @@
+__version__ = "0.62.0"
+
+API_VERSION = "v0.1.495"
+SDK_VERSION = __version__

{viam_sdk-0.25.2.dist-info → viam_sdk-0.62.0.dist-info}/METADATA

@@ -1,26 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: viam-sdk
-Version: 0.25.2
+Version: 0.62.0
 Summary: Viam Robotics Python SDK
-Home-page: https://www.viam.com
-License: Apache-2.0
-Author: Naveed
-Author-email: naveed@viam.com
-Requires-Python: >=3.8.1,<3.13
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: mlmodel
-Requires-Dist: googleapis-common-protos (>=1.60.0,<2)
-Requires-Dist: grpclib (>=0.4.7,<1)
-Requires-Dist: numpy (>=1.21,<2) ; extra == "mlmodel"
-Requires-Dist: protobuf (>=4.24.3)
-Requires-Dist: typing-extensions (>=4.8.0,<5)
+Project-URL: Homepage, https://www.viam.com
 Project-URL: Documentation, https://python.viam.dev
 Project-URL: Repository, https://github.com/viamrobotics/viam-python-sdk
+Author-email: Naveed Jooma <naveed@viam.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.8.1
+Requires-Dist: googleapis-common-protos>=1.65.0
+Requires-Dist: grpclib>=0.4.7
+Requires-Dist: protobuf==5.29.5
+Requires-Dist: pymongo>=4.10.1
+Requires-Dist: typing-extensions>=4.12.2
+Provides-Extra: mlmodel
+Requires-Dist: numpy; extra == 'mlmodel'
 Description-Content-Type: text/markdown
 
 # Viam Python SDK
@@ -43,14 +38,18 @@ Currently, we have pre-built binaries for macOS (both Intel `x86_64` and Apple S
 
 `pip install viam-sdk`
 
+If you want to install on Windows, you can install from github directly with `pip`:
+
+`pip install git+https://github.com/viamrobotics/viam-python-sdk.git`
+
+Note that only direct gRPC connections are supported on Windows; you will need to [disable webrtc](https://python.viam.dev/autoapi/viam/rpc/dial/index.html#viam.rpc.dial.DialOptions.disable_webrtc) or else connection will fail. Full support (including webRTC) _does_ exist on WSL.
+
 If you intend to use the [`MLModel` service](https://python.viam.dev/autoapi/viam/services/mlmodel/mlmodel/index.html#viam.services.mlmodel.mlmodel.MLModel), use the following command instead, which installs additional required dependencies:
 
 `pip install 'viam-sdk[mlmodel]'`
 
 You can also run this command on an existing Python SDK install to add support for the ML model service.
-See the [ML (machine learning) model service](https://docs.viam.com/ml/) documentation for more information.
-
-Windows is not supported. If you are using Windows, install `viam-sdk` in WSL. For other unsupported systems, read further on how to install from source.
+See the [ML (machine learning) model service](https://docs.viam.com/data-ai/ai/deploy/) documentation for more information.
 
 ### Upgrading
 
@@ -70,7 +69,7 @@ The Viam Python SDK uses native libraries to support communication over WebRTC,
    - If you provided the `--release` flag, the enclosing directory will be `release`: `rust-utils/target/release/libviam_rust_utils.*`
    - The extension of the executable will depend on your operating system. For example, on macOS it will be `libviam_rust_utils.dylib`, whereas on Linux it will be `libviam_rust_utils.so`
 1. Copy the compiled library to the directory `viam-python-sdk/src/viam/rpc/`
-1. From the `viam-python-sdk` directory, run `poetry build` to create an installable package
+1. From the `viam-python-sdk` directory, run `uv build --wheel` to create an installable package
 1. Find the newly created installable package located in `viam-python-sdk/dist/` and pip install it directly, for example: `pip install viam-python-sdk/dist/viam_sdk-0.1.0-py3-none-any.whl`
 
 If you have a macOS or Linux based operating system and do not want to build rust-utils manually, you can also look for the executable in the [releases](https://github.com/viamrobotics/rust-utils/releases/latest) page of the rust-utils library.
@@ -78,7 +77,7 @@ If you have a macOS or Linux based operating system and do not want to build rus
 If you do **NOT** need communication over WebRTC (and thus, do not need the native library), the steps are:
 
 1. Download/clone this repository
-1. Run `poetry build` from the `viam-python-sdk` directory
+1. Run `uv build --wheel` from the `viam-python-sdk` directory
 1. Find the newly created installable package located in `viam-python-sdk/dist/` and pip install it directly, for example: `pip install viam-python-sdk/dist/viam_sdk-0.1.0-py3-none-any.whl`
 1. Ensure that every connection has the option `disable_webrtc` set to `True`: `viam.rpc.dial.DialOptions(disable_webrtc=True)`
    - For more information about connecting to a robot, see the [documentation](https://python.viam.dev) and [example usage](https://python.viam.dev/examples/example.html)
@@ -92,7 +91,8 @@ To create a client application, to navigate to [app.viam.com](https://app.viam.c
 1. Create a location (for example `home`)
 2. Create a robot (for example `arduino`)
 3. Follow the steps on the setup tab:
-   1. Setup Viam App Config on Single Board Computer (SBC)
+
+   1. Setup machine cloud credentials on Single Board Computer (SBC)
    2. Download and Install Viam Server
    3. Wait until the robot shows as connected. If this doesn't happen try restarting the viam-server:
 
@@ -146,13 +146,12 @@ The SDK provides a number of abstract base components and services (collectively
    1. Define all requirements of the resource in `{RESOURCE_NAME}.py`
    1. Implement the gRPC service for the new resource in `service.py`
    1. Create a gRPC client for the new resource in `client.py`
-   1. Register the subtype and define package exports in `__init__.py`
+   1. Register the API and define package exports in `__init__.py`
 1. Write tests for the new resource and add the resource to `tests.mocks.{components|services}`
 1. If the resource is a component, add the component to `examples.server.v1.components` and its corresponding concrete type in `examples.server.v1.server`
 
 ## License
 
-Copyright 2021-2023 Viam Inc.
+Copyright 2021-2024 Viam Inc.
 
 Apache 2.0 - See [LICENSE](https://github.com/viamrobotics/viam-python-sdk/blob/main/LICENSE) file
-