bosdyn-client 5.0.0__py3-none-any.whl → 5.0.1.1__py3-none-any.whl

bosdyn/client/audio_visual.py

@@ -0,0 +1,517 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+import collections
+import math
+
+from bosdyn.api import audio_visual_pb2, audio_visual_service_pb2_grpc
+from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,
+                                  handle_common_header_errors, handle_unset_status_error)
+
+from .exceptions import Error as BaseError
+from .exceptions import ResponseError
+
+
+class AudioVisualResponseError(ResponseError):
+    """General class of errors for AudioVisual service."""
+
+
+class Error(BaseError):
+    """Base class for non-response errors in this module."""
+
+
+class NoTimeSyncError(BaseError):
+    """Client has not done timesync with robot."""
+
+
+class DoesNotExistError(AudioVisualResponseError):
+    """The specified behavior does not exist."""
+
+
+class PermanentBehaviorError(AudioVisualResponseError):
+    """Permanent behaviors cannot be modified or deleted."""
+
+
+class BehaviorExpiredError(AudioVisualResponseError):
+    """The specified end_time has already expired."""
+
+
+class InvalidBehaviorError(AudioVisualResponseError):
+    """The request contained a behavior with invalid fields."""
+
+
+class InvalidClientError(AudioVisualResponseError):
+    """The behavior cannot be stopped because a different client is running it."""
+
+
+class AudioVisualClient(BaseClient):
+    """Client for calling the Audio Visual Service."""
+    default_service_name = 'audio-visual'
+    service_type = 'bosdyn.api.AudioVisualService'
+
+    def __init__(self):
+        super(AudioVisualClient,
+              self).__init__(audio_visual_service_pb2_grpc.AudioVisualServiceStub)
+        self.timesync_endpoint = None
+
+    def update_from(self, other):
+        """Update instance from another object.
+
+        Args:
+            other: The object where to copy from.
+        """
+        super(AudioVisualClient, self).update_from(other)
+
+        # Grab a timesync endpoint if it is available.
+        try:
+            self.timesync_endpoint = other.time_sync.endpoint
+        except AttributeError:
+            pass  # other doesn't have a time_sync accessor
+
+    def run_behavior(self, name, end_time_secs, restart=False, timesync_endpoint=None, **kwargs):
+        """Run a behavior on the robot.
+
+        Args:
+            name: The name of the behavior to run.
+            end_time_secs: The time that this behavior should stop.
+            restart: If this behavior is already running, should we restart it from the beginning.
+            timesync_endpoint: Timesync endpoint.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            DoesNotExistError: The behavior name specified has not been added to the system.
+            BehaviorExpiredError: The specified end_time has already expired.
+            NoTimeSyncError: Time sync has not been established with the robot yet.
+        """
+
+        end_time = self._timestamp_to_robot_time(end_time_secs, timesync_endpoint)
+        req = audio_visual_pb2.RunBehaviorRequest(name=name, end_time=end_time, restart=restart)
+        return self.call(self._stub.RunBehavior, req, error_from_response=_run_behavior_error,
+                         copy_request=False, **kwargs)
+
+    def run_behavior_async(self, name, end_time_secs, restart=False, timesync_endpoint=None,
+                           **kwargs):
+        """Async version of run_behavior().
+
+        Args:
+            name: The name of the behavior to run.
+            end_time_secs: The time that this behavior should stop.
+            restart: If this behavior is already running, should we restart it from the beginning.
+            timesync_endpoint: Timesync endpoint.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            DoesNotExistError: The behavior name specified has not been added to the system.
+            BehaviorExpiredError: The specified end_time has already expired.
+            NoTimeSyncError: Time sync has not been established with the robot yet.
+        """
+
+        end_time = self._timestamp_to_robot_time(end_time_secs, timesync_endpoint)
+        req = audio_visual_pb2.RunBehaviorRequest(name=name, end_time=end_time, restart=restart)
+        return self.call_async(self._stub.RunBehavior, req, error_from_response=_run_behavior_error,
+                               copy_request=False, **kwargs)
+
+    def stop_behavior(self, name, **kwargs):
+        """Stop a behavior that is currently running.
+
+        Args:
+            name: The name of the behavior to stop.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            InvalidClientError: A different client is running this behavior."""
+
+        req = audio_visual_pb2.StopBehaviorRequest(behavior_name=name)
+
+        return self.call(self._stub.StopBehavior, req, error_from_response=_stop_behavior_error,
+                         copy_request=False, **kwargs)
+
+    def stop_behavior_async(self, name, **kwargs):
+        """Async version of stop_behavior().
+
+        Args:
+            name: The name of the behavior to stop.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            InvalidClientError: A different client is running this behavior."""
+
+        req = audio_visual_pb2.StopBehaviorRequest(behavior_name=name)
+
+        return self.call_async(self._stub.StopBehavior, req,
+                               error_from_response=_stop_behavior_error, copy_request=False,
+                               **kwargs)
+
+    def add_or_modify_behavior(self, name, behavior, **kwargs):
+        """Add or modify an AudioVisualBehavior.
+
+        Args:
+            name: The name of the behavior to add.
+            behavior: The AudioVisualBehavior proto to add.
+
+        Returns:
+            The LiveAudioVisualBehavior proto that was just added or modified.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            PermanentBehaviorError: The behavior specified is permanent and cannot be modified.
+            InvalidBehaviorError: The request contained a behavior with invalid fields.
+        """
+        # Clamp and normalize colors in the behavior before sending the request.
+        led_sequence_group = getattr(behavior, "led_sequence_group", None)
+        if led_sequence_group is not None:
+            behavior.led_sequence_group.CopyFrom(check_color(led_sequence_group))
+
+        req = audio_visual_pb2.AddOrModifyBehaviorRequest(name=name, behavior=behavior)
+        return self.call(self._stub.AddOrModifyBehavior, req,
+                         value_from_response=_get_live_behavior,
+                         error_from_response=_add_or_modify_behavior_error, copy_request=False,
+                         **kwargs)
+
+    def add_or_modify_behavior_async(self, name, behavior, **kwargs):
+        """Add or modify an AudioVisualBehavior.
+
+        Args:
+            name: The name of the behavior to add.
+            behavior: The AudioVisualBehavior proto to add.
+
+        Returns:
+            The LiveAudioVisualBehavior proto that was just added or modified.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            PermanentBehaviorError: The behavior specified is permanent and cannot be modified.
+            InvalidBehaviorError: The request contained a behavior with invalid fields.
+        """
+        # Clamp and normalize colors in the behavior before sending the request.
+        led_sequence_group = getattr(behavior, "led_sequence_group", None)
+        if led_sequence_group is not None:
+            behavior.led_sequence_group.CopyFrom(check_color(led_sequence_group))
+
+        req = audio_visual_pb2.AddOrModifyBehaviorRequest(name=name, behavior=behavior)
+        return self.call_async(self._stub.AddOrModifyBehavior, req,
+                               value_from_response=_get_live_behavior,
+                               error_from_response=_add_or_modify_behavior_error,
+                               copy_request=False, **kwargs)
+
+    def delete_behaviors(self, behavior_names, **kwargs):
+        """Delete an AudioVisualBehavior.
+
+        Args:
+            behavior_names: A list of behavior names to delete.
+
+        Returns:
+            A list of LiveAudioVisualBehavior protos that were deleted.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            DoesNotExistError: A specified behavior name has not been added to the system.
+            PermanentBehaviorError: A specified behavior is permanent and cannot be deleted.
+        """
+
+        req = audio_visual_pb2.DeleteBehaviorsRequest(behavior_names=behavior_names)
+        return self.call(self._stub.DeleteBehaviors, req,
+                         value_from_response=_get_deleted_behaviors,
+                         error_from_response=_delete_behaviors_error, copy_request=False, **kwargs)
+
+    def delete_behaviors_async(self, behavior_names, **kwargs):
+        """Async version of delete_behaviors().
+
+        Args:
+            behavior_names: A list of behavior names to delete.
+
+        Returns:
+            A list of LiveAudioVisualBehavior protos that were deleted.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            DoesNotExistError: A specified behavior name has not been added to the system.
+            PermanentBehaviorError: A specified behavior is permanent and cannot be deleted.
+        """
+
+        req = audio_visual_pb2.DeleteBehaviorsRequest(behavior_names=behavior_names)
+        return self.call_async(self._stub.DeleteBehaviors, req,
+                               value_from_response=_get_deleted_behaviors,
+                               error_from_response=_delete_behaviors_error, copy_request=False,
+                               **kwargs)
+
+    def list_behaviors(self, **kwargs):
+        """List all currently added AudioVisualBehaviors.
+
+        Returns:
+            A list of all LiveAudioVisualBehavior protos.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+
+        req = audio_visual_pb2.ListBehaviorsRequest()
+        return self.call(self._stub.ListBehaviors, req, value_from_response=_get_behavior_list,
+                         error_from_response=common_header_errors, copy_request=False, **kwargs)
+
+    def list_behaviors_async(self, **kwargs):
+        """Async version of list_behaviors().
+
+        Returns:
+            A list of all LiveAudioVisualBehavior protos.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+
+        req = audio_visual_pb2.ListBehaviorsRequest()
+        return self.call_async(self._stub.ListBehaviors, req,
+                               value_from_response=_get_behavior_list,
+                               error_from_response=common_header_errors, copy_request=False,
+                               **kwargs)
+
+    def get_system_params(self, **kwargs):
+        """Get the current system params.
+
+        Returns:
+            An AudioVisualSystemParams proto containing the current system param values.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+
+        req = audio_visual_pb2.GetSystemParamsRequest()
+        return self.call(self._stub.GetSystemParams, req, error_from_response=common_header_errors,
+                         copy_request=False, **kwargs)
+
+    def get_system_params_async(self, **kwargs):
+        """Async version of get_system_params().
+
+        Returns:
+            An AudioVisualSystemParams proto containing the current system param values.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+
+        req = audio_visual_pb2.GetSystemParamsRequest()
+        return self.call_async(self._stub.GetSystemParams, req,
+                               error_from_response=common_header_errors, copy_request=False,
+                               **kwargs)
+
+    def set_system_params(self, enabled=None, max_brightness=None, buzzer_max_volume=None,
+                          speaker_max_volume=None, normal_color_association=None,
+                          warning_color_association=None, danger_color_association=None, **kwargs):
+        """Set the system params.
+
+        Args:
+            enabled: [optional] System is enabled or disabled (boolean).
+            max_brightness: [optional] New max_brightness value [0, 1].
+            buzzer_max_volume: [optional] New buzzer_max_volume value [0, 1].
+            speaker_max_volume: [optional] New speaker_max_volume value [0, 1].
+            normal_color_association: [optional] The color to associate with the normal color preset.
+            warning_color_association: [optional] The color to associate with the warning color preset.
+            danger_color_association: [optional] The color to associate with the danger color preset.
+
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+
+        req = audio_visual_pb2.SetSystemParamsRequest()
+        if (enabled is not None):
+            req.enabled.value = enabled
+        if (max_brightness is not None):
+            req.max_brightness.value = max_brightness
+        if (buzzer_max_volume is not None):
+            req.buzzer_max_volume.value = buzzer_max_volume
+        if (speaker_max_volume is not None):
+            req.speaker_max_volume.value = speaker_max_volume
+        if (normal_color_association is not None):
+            req.normal_color_association.CopyFrom(normal_color_association)
+        if (warning_color_association is not None):
+            req.warning_color_association.CopyFrom(warning_color_association)
+        if (danger_color_association is not None):
+            req.danger_color_association.CopyFrom(danger_color_association)
+        return self.call(self._stub.SetSystemParams, req, error_from_response=common_header_errors,
+                         copy_request=False, **kwargs)
+
+    def set_system_params_async(self, enabled=None, max_brightness=None, buzzer_max_volume=None,
+                                speaker_max_volume=None, normal_color_association=None,
+                                warning_color_association=None, danger_color_association=None,
+                                **kwargs):
+        """Async version of set_system_params().
+
+        Args:
+            enabled: [optional] System is enabled or disabled (boolean).
+            max_brightness: [optional] New max_brightness value [0, 1].
+            buzzer_max_volume: [optional] New buzzer_max_volume value [0, 1].
+            speaker_max_volume: [optional] New speaker_max_volume value [0, 1].
+            normal_color_association: [optional] The color to associate with the normal color preset.
+            warning_color_association: [optional] The color to associate with the warning color preset.
+            danger_color_association: [optional] The color to associate with the danger color preset.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+
+        req = audio_visual_pb2.SetSystemParamsRequest()
+        if (enabled is not None):
+            req.enabled.value = enabled
+        if (max_brightness is not None):
+            req.max_brightness.value = max_brightness
+        if (buzzer_max_volume is not None):
+            req.buzzer_max_volume.value = buzzer_max_volume
+        if (speaker_max_volume is not None):
+            req.speaker_max_volume.value = speaker_max_volume
+        if (normal_color_association is not None):
+            req.normal_color_association.CopyFrom(normal_color_association)
+        if (warning_color_association is not None):
+            req.warning_color_association.CopyFrom(warning_color_association)
+        if (danger_color_association is not None):
+            req.danger_color_association.CopyFrom(danger_color_association)
+        return self.call_async(self._stub.SetSystemParams, req,
+                               error_from_response=common_header_errors, copy_request=False,
+                               **kwargs)
+
+    def _timestamp_to_robot_time(self, timestamp, timesync_endpoint=None):
+        # Create a time converter to convert timestamp to robot time
+        time_converter = None
+        if (timesync_endpoint):
+            time_converter = timesync_endpoint.get_robot_time_converter()
+        elif (self.timesync_endpoint):
+            time_converter = self.timesync_endpoint.get_robot_time_converter()
+        else:
+            raise NoTimeSyncError("No timesync endpoint was passed to audio visual client.")
+
+        return time_converter.robot_timestamp_from_local_secs(timestamp)
+
+
+def _get_behavior_list(response):
+    return response.behaviors
+
+
+def _get_live_behavior(response):
+    return response.live_behavior
+
+
+def _get_deleted_behaviors(response):
+    return response.deleted_behaviors
+
+
+_AUDIO_VISUAL_RUN_BEHAVIOR_STATUS_TO_ERROR = collections.defaultdict(
+    lambda: (AudioVisualResponseError, None))
+_AUDIO_VISUAL_RUN_BEHAVIOR_STATUS_TO_ERROR.update({
+    audio_visual_pb2.RunBehaviorResponse.STATUS_SUCCESS: (None, None),
+    audio_visual_pb2.RunBehaviorResponse.STATUS_DOES_NOT_EXIST: error_pair(DoesNotExistError),
+    audio_visual_pb2.RunBehaviorResponse.STATUS_EXPIRED: error_pair(BehaviorExpiredError),
+})
+
+_AUDIO_VISUAL_STOP_BEHAVIOR_STATUS_TO_ERROR = collections.defaultdict(
+    lambda: (AudioVisualResponseError, None))
+_AUDIO_VISUAL_STOP_BEHAVIOR_STATUS_TO_ERROR.update({
+    audio_visual_pb2.StopBehaviorResponse.STATUS_SUCCESS: (None, None),
+    audio_visual_pb2.StopBehaviorResponse.STATUS_INVALID_CLIENT: error_pair(InvalidClientError)
+})
+
+_AUDIO_VISUAL_ADD_OR_MODIFY_BEHAVIOR_STATUS_TO_ERROR = collections.defaultdict(
+    lambda: (AudioVisualResponseError, None))
+_AUDIO_VISUAL_ADD_OR_MODIFY_BEHAVIOR_STATUS_TO_ERROR.update({
+    audio_visual_pb2.AddOrModifyBehaviorResponse.STATUS_SUCCESS: (None, None),
+    audio_visual_pb2.AddOrModifyBehaviorResponse.STATUS_INVALID:
+        error_pair(InvalidBehaviorError),
+    audio_visual_pb2.AddOrModifyBehaviorResponse.STATUS_MODIFY_PERMANENT:
+        error_pair(PermanentBehaviorError),
+})
+
+_AUDIO_VISUAL_DELETE_BEHAVIORS_STATUS_TO_ERROR = collections.defaultdict(
+    lambda: (AudioVisualResponseError, None))
+_AUDIO_VISUAL_DELETE_BEHAVIORS_STATUS_TO_ERROR.update({
+    audio_visual_pb2.DeleteBehaviorsResponse.STATUS_SUCCESS: (None, None),
+    audio_visual_pb2.DeleteBehaviorsResponse.STATUS_DOES_NOT_EXIST:
+        error_pair(DoesNotExistError),
+    audio_visual_pb2.DeleteBehaviorsResponse.STATUS_DELETE_PERMANENT:
+        error_pair(PermanentBehaviorError),
+})
+
+
+@handle_common_header_errors
+@handle_unset_status_error(unset='STATUS_UNKNOWN')
+def _run_behavior_error(response):
+    """RunBehaviorResponse response to exception."""
+    return error_factory(response, response.status,
+                         status_to_string=audio_visual_pb2.RunBehaviorResponse.Status.Name,
+                         status_to_error=_AUDIO_VISUAL_RUN_BEHAVIOR_STATUS_TO_ERROR)
+
+
+@handle_common_header_errors
+@handle_unset_status_error(unset='STATUS_UNKNOWN')
+def _stop_behavior_error(response):
+    """StopBehaviorResponse response to exception."""
+    return error_factory(response, response.status,
+                         status_to_string=audio_visual_pb2.StopBehaviorResponse.Status.Name,
+                         status_to_error=_AUDIO_VISUAL_STOP_BEHAVIOR_STATUS_TO_ERROR)
+
+
+@handle_common_header_errors
+@handle_unset_status_error(unset='STATUS_UNKNOWN')
+def _add_or_modify_behavior_error(response):
+    """AddOrModifyBehaviorResponse response to exception."""
+    return error_factory(response, response.status,
+                         status_to_string=audio_visual_pb2.AddOrModifyBehaviorResponse.Status.Name,
+                         status_to_error=_AUDIO_VISUAL_ADD_OR_MODIFY_BEHAVIOR_STATUS_TO_ERROR)
+
+
+@handle_common_header_errors
+@handle_unset_status_error(unset='STATUS_UNKNOWN')
+def _delete_behaviors_error(response):
+    """DeleteBehaviorResponse response to exception."""
+    return error_factory(response, response.status,
+                         status_to_string=audio_visual_pb2.DeleteBehaviorsResponse.Status.Name,
+                         status_to_error=_AUDIO_VISUAL_DELETE_BEHAVIORS_STATUS_TO_ERROR)
+
+
+def check_color(led_sequence_group):
+    # Check every LED
+    leds = ["center", "front_left", "front_right", "hind_left", "hind_right"]
+    for led in leds:
+        # Get the LED sequence by location
+        led_sequence = getattr(led_sequence_group, led, None)
+        if led_sequence is not None:
+            # Now, normalize the color in the LED sequence by location
+            if led_sequence.HasField("animation_sequence"):
+                for frame, idx in enumerate(led_sequence.animation_sequence.frames):
+                    if frame.HasField("color"):
+                        color = clamp_and_normalize_color(frame.color)
+                        led_sequence.animation_sequence.frames[idx] = color
+            elif led_sequence.HasField("blink_sequence"):
+                if led_sequence.blink_sequence.HasField("color"):
+                    led_sequence.blink_sequence.color.CopyFrom(
+                        clamp_and_normalize_color(led_sequence.blink_sequence.color))
+            elif led_sequence.HasField("pulse_sequence"):
+                if led_sequence.pulse_sequence.HasField("color"):
+                    led_sequence.pulse_sequence.color.CopyFrom(
+                        clamp_and_normalize_color(led_sequence.pulse_sequence.color))
+            elif led_sequence.HasField("synced_blink_sequence"):
+                for frame, idx in enumerate(led_sequence.synced_blink_sequence.frames):
+                    if frame.HasField("color"):
+                        color = clamp_and_normalize_color(frame.color)
+                        led_sequence.synced_blink_sequence.frames[idx] = color
+            elif led_sequence.HasField("solid_color_sequence"):
+                if led_sequence.solid_color_sequence.HasField("color"):
+                    led_sequence.solid_color_sequence.color.CopyFrom(
+                        clamp_and_normalize_color(led_sequence.solid_color_sequence.color))
+    return led_sequence_group
+
+
+# Scale color so that their Euclidean norm does not exceed max_color_magnitude.
+# NOTE: max_color_magnitude of 255 (roughly 50% of sqrt(3*255^2)=441.67) is a heuristic chosen to prevent damage to the robot's LEDs.
+# Exceeding this value may result in damage to the robot's LEDs that will NOT be covered under warranty.
+def clamp_and_normalize_color(color, max_color_magnitude=255):
+    r, g, b = color.rgb.r, color.rgb.g, color.rgb.b
+    norm = math.sqrt(r**2 + g**2 + b**2)
+    if norm > max_color_magnitude and norm > 0:
+        scale = max_color_magnitude / norm
+        scaled_color = audio_visual_pb2.Color(
+            rgb=audio_visual_pb2.Color.RGB(r=int(r * scale), g=int(g * scale), b=int(b * scale)))
+        print(f"Input color {color} scaled by {scale:.2f}. Clamped color: {scaled_color}.")
+        color = scaled_color
+    return color

bosdyn/client/audio_visual_helpers.py

@@ -0,0 +1,112 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+import logging
+import threading
+import time
+from concurrent.futures import Future
+
+import bosdyn.client
+from bosdyn.api import audio_visual_pb2
+from bosdyn.client.audio_visual import (AudioVisualClient, BehaviorExpiredError, DoesNotExistError,
+                                        InvalidClientError)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AudioVisualHelper:
+    """Context manager that runs an AV behavior for the duration of the context.
+
+    Use as follows:
+
+    .. code-block:: python
+
+        with AudioVisualHelper(robot, behavior_name, refresh_rate):
+            # Lights and sounds will play here
+        # Lights and sounds will stop here.
+
+    Args:
+        robot: Robot object for creating clients
+        behavior_name: Name of the desired behavior to run
+        refresh_rate: What rate to refresh the behavior (seconds)
+    """
+
+    def __init__(self, robot, behavior_name, refresh_rate, logger=None):
+        self.robot = robot
+        self.logger = logger
+        self.behavior_name = behavior_name
+        self.refresh_rate = refresh_rate
+        self.av_client = None
+        self._behavior_running_fut = None
+
+        try:
+            self.av_client = robot.ensure_client(AudioVisualClient.default_service_name)
+        except:
+            _LOGGER.warning("Could not initialize AV client, skipping AudioVisualHelper.")
+
+        self.av_thread = None
+        self.stop_event = threading.Event()
+
+    def __enter__(self):
+        self._behavior_running_fut = Future()
+        self._behavior_running_fut.set_running_or_notify_cancel()
+
+        if self.av_client:
+            self.av_thread = threading.Thread(target=self._run_behavior_thread, args=())
+            self.av_thread.start()
+        else:
+            self._behavior_running_fut.set_result(False)
+
+        return self._behavior_running_fut
+
+    def __exit__(self, exc_type, exc_value, tb):
+        if self.av_thread:
+            self.stop_event.set()
+            self.av_thread.join()
+
+    def _run_behavior_thread(self):
+        # Check if the robot has AV hardware
+        if not self.robot.get_cached_hardware_hardware_configuration().has_audio_visual_system:
+            self._behavior_running_fut.set_result(False)
+            return
+
+        def set_future_result(result):
+            if not self._behavior_running_fut.done():
+                self._behavior_running_fut.set_result(result)
+
+        def set_future_exception(exc):
+            if not self._behavior_running_fut.done():
+                self._behavior_running_fut.set_exception(exc)
+
+        # Run the AV behavior until the stop_event is triggered
+        while not self.stop_event.wait(self.refresh_rate):
+            try:
+                end_time_secs = time.time() + self.refresh_rate + 0.10  # add 100ms margin
+                result = self.av_client.run_behavior(self.behavior_name, end_time_secs)
+                set_future_result(
+                    result.run_result == audio_visual_pb2.RunBehaviorResponse.RESULT_BEHAVIOR_RUN)
+            except DoesNotExistError as exc:
+                set_future_exception(exc)
+                _LOGGER.exception(f'Audio Visual Behavior {self.behavior_name} does not exist.')
+                return  # Since the behavior doesn't exist, we can stop trying to run it
+            except BehaviorExpiredError as exc:
+                set_future_exception(exc)
+                _LOGGER.warning('Behavior was expired when received by client.')
+            except bosdyn.client.PersistentRpcError as exc:
+                set_future_exception(exc)
+                _LOGGER.exception('Failed to run behavior. Quitting AudioVisualHelper.')
+                return  # A persistent error means we can't talk to the AV service, we can stop.
+            except bosdyn.client.RpcError:
+                _LOGGER.exception('Failed to run behavior. Retrying.')
+            except bosdyn.client.Error as exc:
+                set_future_exception(exc)
+                _LOGGER.exception('Unknown exception caught, quitting AudioVisualHelper.')
+                return
+
+        try:
+            self.av_client.stop_behavior(self.behavior_name)
+        except InvalidClientError:
+            _LOGGER.warning('Failed to stop behavior, run by a different client.')

bosdyn/client/directory_registration.py

@@ -19,7 +19,8 @@ from bosdyn.api import (directory_pb2, directory_registration_pb2,
 from bosdyn.client.common import (BaseClient, error_factory, error_pair,
                                   handle_common_header_errors, handle_unset_status_error)
 
-from .exceptions import ResponseError, RetryableUnavailableError, TimedOutError
+from .error_callback_result import ErrorCallbackResult
+from .exceptions import ResponseError, RetryableUnavailableError, RpcError, TimedOutError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -299,10 +300,12 @@ class DirectoryRegistrationKeepAlive(object):
       rpc_timeout_seconds: Number of seconds to wait for a dir_reg_client RPC. Defaults to None,
           for no timeout.
       rpc_interval_seconds: Interval at which to request service registrations.
+      initial_retry_seconds: Initial number of seconds to wait before retrying a failed
+          registration request. Defaults to 1 second.
     """
 
     def __init__(self, dir_reg_client, logger=None, rpc_timeout_seconds=None,
-                 rpc_interval_seconds=30):
+                 rpc_interval_seconds=30, initial_retry_seconds=1):
         self.authority = None
         self.directory_name = None
         self.host = None
@@ -310,11 +313,15 @@ class DirectoryRegistrationKeepAlive(object):
         self.port = None
         self.service_type = None
         self.dir_reg_client = dir_reg_client
+        #: Callable[[Exception], ErrorCallbackResult] | None: Optional callback to be called when
+        #: an error occurs in the reregistration thread.
+        self.reregistration_error_callback = None
 
         self._end_reregister_signal = threading.Event()
         self._lock = threading.Lock()
         self._rpc_timeout = rpc_timeout_seconds
         self._reregister_period = rpc_interval_seconds
+        self._initial_retry_seconds = initial_retry_seconds
 
         # Configure the thread to do re-registration.
         self._thread = threading.Thread(target=self._periodic_reregister)
@@ -430,9 +437,13 @@ class DirectoryRegistrationKeepAlive(object):
         Raises:
           RpcError: Problem communicating with the robot.
         """
+        retry_interval = self._initial_retry_seconds
+        wait_time = self._reregister_period
+
         self.logger.info('Starting directory registration loop for {}'.format(self.directory_name))
-        while True:
+        while not self._end_reregister_signal.wait(wait_time):
             exec_start = time.time()
+            action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
             try:
                 self.dir_reg_client.register(
                     self.directory_name,
@@ -454,9 +465,27 @@ class DirectoryRegistrationKeepAlive(object):
                 pass
             except TimedOutError:
                 self.logger.warning('Timed out, timeout set to "{}"'.format(self._rpc_timeout))
+            except RpcError as exc:
+                self.logger.exception('Reregistration failed with RpcError')
+                if self.reregistration_error_callback is not None:
+                    try:
+                        action = self.reregistration_error_callback(exc)
+                    except Exception:  #pylint: disable=broad-except
+                        self.logger.exception('Exception thrown in the provided error callback')
             except Exception:
                 # Log all other exceptions, but continue looping in hopes that it resolves itself
                 self.logger.exception('Caught general exception')
-            exec_sec = time.time() - exec_start
-            if self._end_reregister_signal.wait(self._reregister_period - exec_sec):
+
+            elapsed = time.time() - exec_start
+            if action == ErrorCallbackResult.RETRY_IMMEDIATELY:
+                wait_time = 0.0
+            elif action == ErrorCallbackResult.ABORT:
                 break
+            elif action == ErrorCallbackResult.RETRY_WITH_EXPONENTIAL_BACK_OFF:
+                wait_time = retry_interval - elapsed
+                retry_interval = min(2.0 * retry_interval, self._reregister_period)
+            else:
+                # action doesn't match one of the enum values or is one of
+                # RESUME_NORMAL_OPERATION or DEFAULT_ACTION
+                retry_interval = self._initial_retry_seconds
+                wait_time = self._reregister_period - elapsed

bosdyn/client/error_callback_result.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
+#
+# Downloading, reproducing, distributing or otherwise using the SDK Software
+# is subject to the terms and conditions of the Boston Dynamics Software
+# Development Kit License (20191101-BDSDK-SL).
+
+import enum
+
+
+class ErrorCallbackResult(enum.Enum):
+    """Enum indicating error resolution for errors encountered on SDK background threads.
+
+    There are a few places in the SDK where errors can occur in background threads and it would
+    be useful to provide these errors to client code to resolve. Once the application's provided
+    callback performs its action, it returns one of these enum values to indicate what the
+    background thread should do next.
+    """
+    #: Take the default action as if no error handler had been provided.
+    DEFAULT_ACTION = 1
+    #: Retry the operation immediately, presumably because the error has been resolved and the
+    #: operation can be retried.
+    RETRY_IMMEDIATELY = 2
+    #: Retry, with the period between successive retries increasing exponentially.
+    RETRY_WITH_EXPONENTIAL_BACK_OFF = 3
+    #: Continue normal operation, presuming the error has been resolved and no further action
+    #: is needed.
+    RESUME_NORMAL_OPERATION = 4
+    #: Abort the loop in the background thread.
+    ABORT = 5

bosdyn/client/gripper_camera_param.py

@@ -4,6 +4,8 @@
 # is subject to the terms and conditions of the Boston Dynamics Software
 # Development Kit License (20191101-BDSDK-SL).
 
+from deprecated.sphinx import deprecated
+
 from bosdyn.api import gripper_camera_param_service_pb2_grpc
 from bosdyn.client.common import BaseClient, common_header_errors
 
@@ -77,12 +79,16 @@ class GripperCameraParamClient(BaseClient):
             get_gripper_camera_calib_request (gripper_camera_params_pb2.GripperCameraGetCalibrationRequest) : The command reqeust to get gripper camera calibration
 
         Returns:
-            The GripperCameraGetCalibrationResponse message, which contains the GripperCameraCalibrationProto 
+            The GripperCameraGetCalibrationResponse message, which contains the GripperCameraCalibrationProto
         """
         return self.call(self._stub.GetCamCalib, get_gripper_camera_calib_request,
                          error_from_response=common_header_errors, **kwargs)
 
-    def get_camera_calib_asnyc(self, get_gripper_camera_calib_request, **kwargs):
-        """Asnyc version of get_camera_calib()."""
+    def get_camera_calib_async(self, get_gripper_camera_calib_request, **kwargs):
+        """Async version of get_camera_calib()."""
         return self.call_async(self._stub.GetCamCalib, get_gripper_camera_calib_request,
                                error_from_response=common_header_errors, **kwargs)
+
+    @deprecated(version='5.0', reason='Use get_camera_calib_async() instead.')
+    def get_camera_calib_asnyc(self, get_gripper_camera_calib_request, **kwargs):
+        return self.get_camera_calib_async(get_gripper_camera_calib_request, **kwargs)

bosdyn/client/keepalive.py

@@ -19,6 +19,7 @@ import bosdyn.util
 from bosdyn.api.keepalive import keepalive_pb2, keepalive_service_pb2_grpc
 from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,
                                   handle_common_header_errors, handle_unset_status_error)
+from bosdyn.client.error_callback_result import ErrorCallbackResult
 from bosdyn.client.exceptions import ResponseError, RetryableRpcError
 
 
@@ -225,7 +226,7 @@ class PolicyKeepalive():
     #pylint: disable=too-many-arguments
     def __init__(self, client: KeepaliveClient, policy: Policy, rpc_timeout_seconds: float = None,
                  rpc_interval_seconds: float = None, logger: 'logging.Logger' = None,
-                 remove_policy_on_exit: bool = False):
+                 remove_policy_on_exit: bool = False, initial_retry_seconds: float = 1.0):
 
         self.logger = logger or logging.getLogger()
         self.remove_policy_on_exit = remove_policy_on_exit
@@ -238,6 +239,11 @@ class PolicyKeepalive():
         # This will raise an exception if there's no action at all.
         self._rpc_interval_seconds = rpc_interval_seconds or policy.shortest_action_delay() / 3
         self._rpc_timeout_seconds = rpc_timeout_seconds
+        self._initial_retry_seconds = initial_retry_seconds
+
+        #: Callable[[Exception], ErrorCallbackResult] | None: Optional callback to be called when
+        #: an error occurs in the keepalive thread.
+        self.keepalive_error_callback = None
 
         self._end_check_in_signal = threading.Event()
         self._thread = threading.Thread(target=self._periodic_check_in)
@@ -277,24 +283,47 @@ class PolicyKeepalive():
         self._end_check_in_signal.set()
 
     def _periodic_check_in(self):
-        while True:
+        retry_interval = self._initial_retry_seconds
+        wait_time = self._rpc_interval_seconds
+
+        # Block and wait for the stop signal. If we receive it within the check-in period,
+        # leave the loop. Under normal conditions, wait up to self._check_in_period seconds, minus
+        # the RPC processing time. (values < 0 are OK and unblock immediately)
+        while not self._end_check_in_signal.wait(wait_time):
             exec_start = time.time()
+            action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
 
             try:
                 self._check_in()
             except RetryableRpcError as exc:
                 self.logger.warning('exception during check-in:\n%s\n', exc)
                 self.logger.info('continuing check-in')
-
+            except Exception as exc:  # pylint: disable=broad-except
+                if self.keepalive_error_callback is not None:
+                    action = ErrorCallbackResult.DEFAULT_ACTION
+                    try:
+                        action = self.keepalive_error_callback(exc)
+                    except Exception:  # pylint: disable=broad-except
+                        self.logger.exception(
+                            'Exception thrown in the provided keepalive error callback')
+                else:
+                    raise
             # How long did the RPC and processing of said RPC take?
             exec_seconds = time.time() - exec_start
 
-            # Block and wait for the stop signal. If we receive it within the check-in period,
-            # leave the loop. This check must be at the end of the loop!
-            # Wait up to self._check_in_period seconds, minus the RPC processing time.
-            # (values < 0 are OK and will return immediately)
-            if self._end_check_in_signal.wait(self._rpc_interval_seconds - exec_seconds):
+            if action == ErrorCallbackResult.ABORT:
+                self.logger.warning('Callback directed the keepalive thread to exit.')
                 break
+            elif action == ErrorCallbackResult.RETRY_IMMEDIATELY:
+                wait_time = 0
+                continue
+            elif action == ErrorCallbackResult.RETRY_WITH_EXPONENTIAL_BACK_OFF:
+                wait_time = retry_interval - exec_seconds
+                retry_interval = min(2 * retry_interval, self._rpc_interval_seconds)
+            else:
+                # Success path, or default action (resume normal operation)
+                wait_time = self._rpc_interval_seconds - exec_seconds
+                retry_interval = self._initial_retry_seconds
         self.logger.info('Policy check-in stopped')
 
 

bosdyn/client/math_helpers.py

@@ -660,6 +660,10 @@ class SE3Pose(object):
         ret[0:3, 3] = [self.x, self.y, self.z]
         return ret
 
+    def translation_norm(self):
+        """Calculates the Euclidean norm (magnitude) of the translation component pose."""
+        return math.sqrt(self.x**2 + self.y**2 + self.z**2)
+
     def mult(self, se3pose):
         """
         Computes the multiplication between the current math_helpers.SE3Pose and the input se3pose.
@@ -1176,4 +1180,4 @@ def quat_to_eulerZYX(q):
         yaw = math.atan2(2 * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z)
         roll = math.atan2(2 * (q.y * q.z + q.w * q.x),
                           q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z)
-    return yaw, pitch, roll
+    return yaw, pitch, roll

bosdyn/client/payload_registration.py

@@ -20,6 +20,7 @@ from bosdyn.client import (ResponseError, RetryableUnavailableError, TimedOutErr
                            TooManyRequestsError)
 from bosdyn.client.common import (BaseClient, error_factory, handle_common_header_errors,
                                   handle_lease_use_result_errors, handle_unset_status_error)
+from bosdyn.client.error_callback_result import ErrorCallbackResult
 
 LOGGER = logging.getLogger('payload_registration_client')
 
@@ -381,16 +382,23 @@ class PayloadRegistrationKeepAlive(object):
           class name is acquired.
       rpc_timeout_secs: Number of seconds to wait for a pay_reg_client RPC. Defaults to None,
           for no timeout.
+      initial_retry_seconds: Number of seconds to wait before retrying registration that failed
+          due to unhandled errors including RPC transport issues.
     """
 
     def __init__(self, pay_reg_client, payload, secret, registration_interval_secs=30, logger=None,
-                 rpc_timeout_secs=None):
+                 rpc_timeout_secs=None, initial_retry_seconds=1.0):
         self.pay_reg_client = pay_reg_client
         self.payload = payload
         self.secret = secret
         self._registration_interval_secs = registration_interval_secs
         self.logger = logger or logging.getLogger(self.__class__.__name__)
         self._rpc_timeout_secs = rpc_timeout_secs
+        self._initial_retry_seconds = initial_retry_seconds
+
+        #: Callable[[Exception], ErrorCallbackResult] | None: Optional callback to be called when
+        #: an error occurs in the re-registration thread.
+        self.reregistration_error_callback = None
 
         # Configure the thread to do re-registration.
         self._end_reregister_signal = threading.Event()
@@ -423,6 +431,7 @@ class PayloadRegistrationKeepAlive(object):
 
         # This will raise an exception if the thread has already started.
         self._thread.start()
+        return self
 
     def is_alive(self):
         """Are we still periodically re-registering?
@@ -445,8 +454,12 @@ class PayloadRegistrationKeepAlive(object):
           RpcError: Problem communicating with the robot.
         """
         self.logger.info('Starting registration loop')
-        while True:
+        retry_interval = self._initial_retry_seconds
+        wait_time = self._registration_interval_secs
+
+        while not self._end_reregister_signal.wait(wait_time):
             exec_start = time.time()
+            action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
             try:
                 self.pay_reg_client.register_payload(self.payload, self.secret)
             except PayloadAlreadyExistsError:
@@ -459,10 +472,31 @@ class PayloadRegistrationKeepAlive(object):
                 self.logger.warning('Timed out, timeout set to "{}"'.format(self._rpc_timeout_secs))
             except TooManyRequestsError:
                 self.logger.warning("Too many requests error")
-            except Exception as exc:
-                # Log all other exceptions, but continue looping in hopes that it resolves itself
-                self.logger.exception('Caught general exception.')
+            except Exception as exc:  # pylint: disable=broad-except
+                # If the application provided an error handler, give it an opportunity to resolve
+                # the issue.
+                if self.reregistration_error_callback is not None:
+                    action = ErrorCallbackResult.DEFAULT_ACTION
+                    try:
+                        action = self.reregistration_error_callback(exc)
+                    except Exception:  # pylint: disable=broad-except
+                        self.logger.exception(
+                            'Exception thrown in the provided re-registration error callback ')
+                else:
+                    # Log all other exceptions, but continue looping in hopes that it resolves itself
+                    self.logger.exception('Caught general exception.')
+
             exec_sec = time.time() - exec_start
-            if self._end_reregister_signal.wait(self._registration_interval_secs - exec_sec):
+            if action == ErrorCallbackResult.ABORT:
+                self.logger.warning('Callback directed the re-registration loop to exit.')
                 break
+            elif action == ErrorCallbackResult.RETRY_IMMEDIATELY:
+                wait_time = 0.0
+            elif action == ErrorCallbackResult.RETRY_WITH_EXPONENTIAL_BACK_OFF:
+                wait_time = retry_interval - exec_sec
+                retry_interval = min(retry_interval * 2, self._registration_interval_secs)
+            else:
+                # Success path, or default action (resume normal operation)
+                wait_time = self._registration_interval_secs - exec_sec
+                retry_interval = self._initial_retry_seconds
         self.logger.info('Re-registration stopped')

bosdyn/client/robot.py

@@ -131,6 +131,10 @@ class Robot(object):
         self._time_sync_thread = None
         self.executor = None
 
+        #: Callable[[Exception], ErrorCallbackResult] | None: Optional callback to be invoked when
+        #: an error occurs in the token refresh thread.
+        self.token_refresh_error_callback = None
+
         # Set default max message length for sending and receiving. These values are used when
         # creating channels.
         self.max_send_message_length = DEFAULT_MAX_MESSAGE_LENGTH

bosdyn/client/sdk.py

@@ -64,6 +64,7 @@ from .spot_check import SpotCheckClient
 from .time_sync import TimeSyncClient
 from .world_object import WorldObjectClient
 
+from .audio_visual import AudioVisualClient  # isort:skip
 
 
 class SdkError(Error):
@@ -111,6 +112,7 @@ _DEFAULT_SERVICE_CLIENTS = [
     AuthClient,
     AutoReturnClient,
     AutowalkClient,
+    AudioVisualClient,
     DataAcquisitionClient,
     DataAcquisitionStoreClient,
     DataBufferClient,

bosdyn/client/service_customization_helpers.py

@@ -356,7 +356,7 @@ class _StringParamValidator(_ParamValidatorInterface):
         if err:
             return err
 
-        if len(self.param_spec.options) > 0:
+        if not self.param_spec.editable and len(self.param_spec.options) > 0:
             if param_value.value not in self.param_spec.options:
                 return CustomParamError(
                     status=CustomParamError.STATUS_INVALID_VALUE, error_messages=[

bosdyn/client/token_manager.py

@@ -14,11 +14,15 @@ import logging
 import threading
 
 from .auth import InvalidTokenError
-from .exceptions import ResponseError, RpcError
+from .error_callback_result import ErrorCallbackResult
+from .exceptions import ResponseError, RpcError, TimedOutError
 from .token_cache import WriteFailedError
 
 _LOGGER = logging.getLogger(__name__)
 
+USER_TOKEN_REFRESH_TIME_DELTA = datetime.timedelta(hours=1)
+USER_TOKEN_RETRY_INTERVAL_START = datetime.timedelta(seconds=1)
+
 
 class TokenManager:
     """Refreshes the user token in the robot object.
@@ -26,10 +30,13 @@ class TokenManager:
        The refresh policy assumes the token is minted and then the manager is
        launched."""
 
-    def __init__(self, robot, timestamp=None):
+    def __init__(self, robot, timestamp=None, refresh_interval=USER_TOKEN_REFRESH_TIME_DELTA,
+                 initial_retry_interval=USER_TOKEN_RETRY_INTERVAL_START):
         self.robot = robot
 
         self._last_timestamp = timestamp or datetime.datetime.now()
+        self._refresh_interval = refresh_interval
+        self._initial_retry_seconds = initial_retry_interval
 
         # Daemon threads can still run during shutdown after python has
         # started to clear out things in globals().
@@ -51,33 +58,55 @@ class TokenManager:
 
     def update(self):
         """Refresh the user token as needed."""
-        USER_TOKEN_REFRESH_TIME_DELTA = datetime.timedelta(hours=1)
-        USER_TOKEN_RETRY_INTERVAL_START = datetime.timedelta(seconds=1)
-
-        retry_interval = USER_TOKEN_RETRY_INTERVAL_START
-        while not self._exit_thread.is_set():
-            elapsed_time = datetime.datetime.now() - self._last_timestamp
-            if elapsed_time >= USER_TOKEN_REFRESH_TIME_DELTA:
-                try:
-                    self.robot.authenticate_with_token(self.robot.user_token)
-                except WriteFailedError:
-                    _LOGGER.exception(
-                        "Failed to save the token to the cache.  Continuing without caching.")
-                except (InvalidTokenError, ResponseError, RpcError):
-                    _LOGGER.exception("Error refreshing the token.  Retry in %s", retry_interval)
-
-                    # Exponential back-off on retrying
-                    self._exit_thread.wait(retry_interval.seconds)
-                    retry_interval = min(2 * retry_interval, USER_TOKEN_REFRESH_TIME_DELTA)
-                    continue
-
-                retry_interval = USER_TOKEN_RETRY_INTERVAL_START
-
-                # Wait until the specified time or get interrupted by user.
+        retry_interval = self._initial_retry_seconds
+        wait_time = min(self._refresh_interval - (datetime.datetime.now() - self._last_timestamp),
+                        self._refresh_interval)
+
+        while not self._exit_thread.wait(wait_time.total_seconds()):
+            start_time = datetime.datetime.now()
+            action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
+            try:
+                self.robot.authenticate_with_token(self.robot.user_token)
                 self._last_timestamp = datetime.datetime.now()
-                elapsed_time = USER_TOKEN_REFRESH_TIME_DELTA
+            except WriteFailedError:
+                _LOGGER.exception(
+                    "Failed to save the token to the cache.  Continuing without caching.")
+            except (InvalidTokenError, ResponseError, RpcError) as exc:
+                _LOGGER.exception("Error refreshing the token.")
+                # Default course of action is to retry with a back-off, unless the application
+                # supplied callback directs us to do otherwise.
+                action = ErrorCallbackResult.RETRY_WITH_EXPONENTIAL_BACK_OFF
+                # If the application provided a callback and the error was encountered while
+                # refreshing the token, invoke the callback so that the application can take
+                # appropriate action.
+                if self.robot.token_refresh_error_callback is not None and not isinstance(
+                        exc, TimedOutError):
+                    try:
+                        action = self.robot.token_refresh_error_callback(exc)
+                    except Exception:  #pylint: disable=broad-except
+                        _LOGGER.exception(
+                            "Exception thrown in the provided token refresh error callback")
+                if action == ErrorCallbackResult.RESUME_NORMAL_OPERATION:
+                    _LOGGER.warning("Refreshing token in %s", self._refresh_interval)
+
+            elapsed = datetime.datetime.now() - start_time
+            if action == ErrorCallbackResult.ABORT:
+                _LOGGER.warning(
+                    "Application-supplied callback directed the token refresh loop to exit.")
+                break
+            elif action == ErrorCallbackResult.RETRY_IMMEDIATELY:
+                _LOGGER.warning("Retrying to refresh token immediately.")
+                wait_time = datetime.timedelta(seconds=0)
+            elif action == ErrorCallbackResult.RESUME_NORMAL_OPERATION:
+                wait_time = self._refresh_interval - elapsed
+                retry_interval = self._initial_retry_seconds
+            else:
+                # action doesn't match one of the enum values or is one of
+                # RETRY_WITH_EXPONENTIAL_BACK_OFF or DEFAULT_ACTION
+                _LOGGER.warning("Retrying token refresh in %s", retry_interval)
+                wait_time = retry_interval - elapsed
+                retry_interval = min(2 * retry_interval, self._refresh_interval)
 
-            self._exit_thread.wait(elapsed_time.seconds)
         message = 'Shutting down monitoring of token belonging to robot {}'.format(
             self.robot.address)
         _LOGGER.debug(message)

{bosdyn_client-5.0.0.dist-info → bosdyn_client-5.0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bosdyn-client
-Version: 5.0.0
+Version: 5.0.1.1
 Summary: Boston Dynamics API client code and interfaces
 Home-page: https://dev.bostondynamics.com/
 Author: Boston Dynamics
@@ -15,8 +15,8 @@ Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
-Requires-Dist: bosdyn-api (==5.0.0)
-Requires-Dist: bosdyn-core (==5.0.0)
+Requires-Dist: bosdyn-api (==5.0.1.1)
+Requires-Dist: bosdyn-core (==5.0.1.1)
 Requires-Dist: grpcio
 Requires-Dist: pyjwt
 Requires-Dist: numpy

{bosdyn_client-5.0.0.dist-info → bosdyn_client-5.0.1.1.dist-info}/RECORD

@@ -8,6 +8,8 @@ bosdyn/client/area_callback_service_servicer.py,sha256=o1kYKV83Q-ud-_rmT17XTSqBd
 bosdyn/client/area_callback_service_utils.py,sha256=R8ljJe8fPszMI6RyuGRyv_QGu63kw1yZAveZydlpERI,5858
 bosdyn/client/arm_surface_contact.py,sha256=DRfPfsFEzfk6ufe080ViqasUefl2ZUtcvcNENgcf55k,3710
 bosdyn/client/async_tasks.py,sha256=gEPev6_jaUCe-G5PqktMiMGb7ohDy0daunxzQD5jafg,5594
+bosdyn/client/audio_visual.py,sha256=_o2kvOuTgYfXfOgCPotBGdg3xYRCz55wv2tZt4VhvgE,23194
+bosdyn/client/audio_visual_helpers.py,sha256=9qksn7epH5jBdbwa6VVMcm2mn8HCVtJuSW1C847Jo6w,4499
 bosdyn/client/auth.py,sha256=YLo6jP0Ssl_Z6rHtTiPiKUNIweDRYub9w3iHdUe6n40,5302
 bosdyn/client/auto_return.py,sha256=kqT1gaaneLYIPFVAFzpvTHRwa8NYYQ2OBf7wViBQudE,5598
 bosdyn/client/autowalk.py,sha256=e57FcAC4fu2BPD57Yy4j1F8DPIPPic0Qt1E0UM-oZWo,5734
@@ -25,20 +27,21 @@ bosdyn/client/data_buffer.py,sha256=Ta-7CCoy_-StzXDm8cLIjvOnMDgKEzKFc9mcDmVkubc,
 bosdyn/client/data_chunk.py,sha256=6xq9zqLD-JH72ZxzEQEKYqhXvb34TlcZoeqAYaXRxCw,1959
 bosdyn/client/data_service.py,sha256=aKfXJCciJ2M2WZRKfdWiLS2n-UEKWSRkOgcTnArbc5o,5201
 bosdyn/client/directory.py,sha256=jWBxnPzBJSrfr4fuLf2VuZGsxOo8Q5iX5tEw6Zx2VY0,4906
-bosdyn/client/directory_registration.py,sha256=tO-OMVYrFr1tU3oVifoFcbjW_EIXWo6bdsdvS_Gr7RA,19101
+bosdyn/client/directory_registration.py,sha256=SV2xWly0Zu1XaWhyJ9eqXYeWSjFbwfyFmup_RjR3Cdw,20806
 bosdyn/client/docking.py,sha256=hYwZNIir3_pt-WvMFiXzMqDCwW8nA5H1BYOUD6_3-00,17596
 bosdyn/client/door.py,sha256=dbBuGcuoZL3gRhxTQoQHKDlnzcML8ELBtQxCQqomYpo,3110
+bosdyn/client/error_callback_result.py,sha256=B3O9D8ceV1ZsS19UvguISlbvJSjtQ1aZfktVuekZXLU,1317
 bosdyn/client/estop.py,sha256=-dy3SP6lcOryyTB_VXe0C_cFk-qK1TNJdSm9DKSz-MM,32073
 bosdyn/client/exceptions.py,sha256=VQg5cSrzB9_pmFcUCbBaRF2QtBUKfdzpR94N3q2rNx0,5323
 bosdyn/client/fault.py,sha256=ymo4M1Vy-bUasD8uOm1pxE1HnjheCds6qA9hZiJbAzY,6050
 bosdyn/client/frame_helpers.py,sha256=Rrm0Zx10LoaVsJv-FPCX02LVQwNkyKVO28lZz7Bmlvg,12572
 bosdyn/client/graph_nav.py,sha256=8sULbBAFaFxJPF3ZdI_kqLYpzA0XbhGO-zECRyVH1J4,70681
-bosdyn/client/gripper_camera_param.py,sha256=Zrd_YQfuaKaNRXSUQpcgsAkQjDVl39XtTIGAy9fKvZI,4393
+bosdyn/client/gripper_camera_param.py,sha256=kxhBffjbq5R-t1OxWEAFguo_tKW5xGIuasdflSmfAwY,4683
 bosdyn/client/image.py,sha256=fn41QOvaAOH7UT7m2ENXayI4fLXg5NQBZrmpLFZVBBE,21980
 bosdyn/client/image_service_helpers.py,sha256=l2hZKqcG7PI05-_bhh8BLkpN4METmG53JCR0YF3q-8Y,40421
 bosdyn/client/inverse_kinematics.py,sha256=KBgvGdnt-JZJvDzbdJ72Kqw8RHoOsqKq_p9rQtvwuKo,1708
 bosdyn/client/ir_enable_disable.py,sha256=6c5MAuO1Fj0RlVcjkP1vhs-qTLiOpM3RnD8F7_ik1Gw,2153
-bosdyn/client/keepalive.py,sha256=C-Vf17-sSfAHq4cbuuVIh7JQM7NLzv2pRekjHJywfdU,13214
+bosdyn/client/keepalive.py,sha256=Sz1sobzkyDfamKfaam7-dP3jIVlVOBs4l6JE5qqTjEA,14892
 bosdyn/client/lease.py,sha256=-B698QATgRuddH_pc5YN2LhMkZDacZP1kkf1MeYjqec,45412
 bosdyn/client/lease_resource_hierarchy.py,sha256=b_YpVCeiJwVQzAy1Xh5h-1HYjpbzZvmDZAcREGCOgBc,3070
 bosdyn/client/lease_validator.py,sha256=Vo5-2mtfCh50i7MDXLf4NlOBOgqd28ynPp2FF7NNGx0,14505
@@ -47,11 +50,11 @@ bosdyn/client/local_grid.py,sha256=YszM_pTmeGuGIwExgRwB76PXJciO6rZqfaL2RHLxAf0,3
 bosdyn/client/log_status.py,sha256=wcKZEFw8GHyWeYKysZ75i3PrLb1r2xVUEAyO3SDmxOI,12656
 bosdyn/client/manipulation_api_client.py,sha256=bdTTqZk73m7l9bty9CNC9Bs-hTTRFEA_wDweMb4mLu4,4204
 bosdyn/client/map_processing.py,sha256=xmwTkAfIIvRbaRnOCj-JTkrfS13n4z_DAqg-sc8hL2Y,10239
-bosdyn/client/math_helpers.py,sha256=Xb74-Yxd85BChnOt7j9uiLKPd3h5aqREeiys0QMJiL8,48608
+bosdyn/client/math_helpers.py,sha256=HLJ2pmul--Ualfa2cWHIgdNAZScK8MC6kjwqNKSCX44,48793
 bosdyn/client/metrics_logging.py,sha256=9gjVK5Xu4JpOqMg4_tKMHd-XHOh--xaiU_OP9zcGOMs,6646
 bosdyn/client/network_compute_bridge_client.py,sha256=L7RmgCRKiPBn3SVwIxCqP0hkEkhRhF5k5xz2BpC-Omk,7966
 bosdyn/client/payload.py,sha256=12vZirEI4-gu9KPHsDg6MH0QCmnxbolWR1j81lvgfVw,2271
-bosdyn/client/payload_registration.py,sha256=ilT-2W1iuCZImLeDlPLovPYg5HJCk7nLTHxod0Rn8nY,22316
+bosdyn/client/payload_registration.py,sha256=rDGMK3ZtI6nmvCFsjm1MjueYglDNuHHu-7Q5V901VM8,24306
 bosdyn/client/payload_software_update.py,sha256=nYrFOxuikVd-cChkx8aZ9gpVQSxjadgPcxyT6eklwT4,8716
 bosdyn/client/payload_software_update_initiation.py,sha256=LDAe_gDUCLDKOC54MbhC-hsywqNMmT_dtnYjmMaef1g,3216
 bosdyn/client/point_cloud.py,sha256=F_AJBYql8b6Ok_-IEmxpV4ajdXZ_GOahPe_QwWLf7xk,8627
@@ -59,18 +62,18 @@ bosdyn/client/power.py,sha256=teVPBPcwsUHvn996upF06Y5MJsfQrE-93ezMXAAYSmA,26955
 bosdyn/client/processors.py,sha256=Z-Djf_I_lhfokB-f_L0PewAY8J95LThdWVju1zJ2BaE,1275
 bosdyn/client/ray_cast.py,sha256=Ca1yJo0aY6OmVAazb19fy44L-9LzcKVxr_fHt_EoQtg,4465
 bosdyn/client/recording.py,sha256=sQ34G_ckrE-M42ER2GUbYI7UibvdrjHycaia58IpJ2s,25913
-bosdyn/client/robot.py,sha256=kOtUJq-cg7ovn7EvePe06l5nCUDnvFYhm0XCwSL2XXE,30909
+bosdyn/client/robot.py,sha256=XQCp9NjcwS4Bhhohjup_AcLlYm67DV0tlPxuqZTwU1M,31114
 bosdyn/client/robot_command.py,sha256=LtoVKlJwwhTmADRMvJIWJ4B5rY_MpdhHnL72zKm1ECU,108248
 bosdyn/client/robot_id.py,sha256=0VZHG9hltwTLAm1_Bt26Xq1O6EROswqNwHvjY7kaplk,2482
 bosdyn/client/robot_state.py,sha256=h551ke5eHdAC7NgVuLphY8FZR899Ii8_lYwuoX1w1nk,7073
-bosdyn/client/sdk.py,sha256=UFG5sRbnzEiB7hlUBIPm9KVceBrEOLGDuLQJtoIdyzM,12864
+bosdyn/client/sdk.py,sha256=XGW0DqlBfZv31LNYjjtU8p-86C5U-x2zJd7bAF3eDzg,12945
 bosdyn/client/server_util.py,sha256=uLT12vs5nAhdJ0ryaKuE82dxXnBOupebyDuzI8tbLRo,10560
-bosdyn/client/service_customization_helpers.py,sha256=KSRp585Ux87Ozj_pGDLbzG119MGnIGf8YDQ8WFs2qGc,49122
+bosdyn/client/service_customization_helpers.py,sha256=GD23vhBfwCi1S4eBYIBoTbvHe9kwap1cbq0CHXlciGw,49155
 bosdyn/client/signals_helpers.py,sha256=Sp91IrMxVU-PeH6TK2njzFCKmFMyshRJqNa4DYRMqDU,3682
 bosdyn/client/spot_check.py,sha256=PKqN3kwL6oISkqwXEm_R4vz0uixIsfowWY9mC0mM8Cc,14619
 bosdyn/client/time_sync.py,sha256=mDkcR5RlAKfAOwEUoBjwxtJFDKuGFGmiDcrOeCO2P_g,23089
 bosdyn/client/token_cache.py,sha256=Vwf9YfsR7pTyu1fLRzXrvDo9hG5GBJcen8Azlo_5_iA,3507
-bosdyn/client/token_manager.py,sha256=FvDFCXKIiGXZNkagKZM41Ut8Q0ChlYHN3O61CzrqMF8,3144
+bosdyn/client/token_manager.py,sha256=FkF2-xWXrKG1ttTH2omhjx7FtbIGnYkB1vAaKEhg3xM,5112
 bosdyn/client/units_helpers.py,sha256=5SAmL8vsnl06oGNjzb57fUkuUbGvtbeNdg4NgW0wYAY,1084
 bosdyn/client/util.py,sha256=Cr_IB1taOh6Hmu1EdTHa_NU08eXnTEG7kzGX_2xDfoE,19968
 bosdyn/client/world_object.py,sha256=CNfZJxwdTjd-Oh35liNdkZ27sAzdnBVFTkpVIICfRTo,17066
@@ -94,7 +97,7 @@ bosdyn/client/spot_cam/power.py,sha256=HS3nJF8hXq9m1JziOIwLHGLtlNMyLgewWBgs-mRZm
 bosdyn/client/spot_cam/ptz.py,sha256=O1m7zDZ92zRmvy9qhjojiphMQwAweTO0HVizQFdWFFE,10630
 bosdyn/client/spot_cam/streamquality.py,sha256=e-RjizZPwZSOS4Jlqb5Ds-mC6uKam252dpEHkb58Oc8,6364
 bosdyn/client/spot_cam/version.py,sha256=R82eyCAY9PfZqbN8D6hNzSeZatpgpsFr995dRt1Mbe0,2856
-bosdyn_client-5.0.0.dist-info/METADATA,sha256=2nuQY0XUTFHO8hKP4nWMxstk-raf3F3O3VCg6ebzh3s,3987
-bosdyn_client-5.0.0.dist-info/WHEEL,sha256=AtBG6SXL3KF_v0NxLf0ehyVOh0cold-JbJYXNGorC6Q,92
-bosdyn_client-5.0.0.dist-info/top_level.txt,sha256=an2OWgx1ej2jFjmBjPWNQ68ZglvUfKhmXWW-WhTtDmA,7
-bosdyn_client-5.0.0.dist-info/RECORD,,
+bosdyn_client-5.0.1.1.dist-info/METADATA,sha256=4xSEgKQR1XVaeQsiKHhel8oRa_4wNT1QJDSMXRUV1-U,3993
+bosdyn_client-5.0.1.1.dist-info/WHEEL,sha256=AtBG6SXL3KF_v0NxLf0ehyVOh0cold-JbJYXNGorC6Q,92
+bosdyn_client-5.0.1.1.dist-info/top_level.txt,sha256=an2OWgx1ej2jFjmBjPWNQ68ZglvUfKhmXWW-WhTtDmA,7
+bosdyn_client-5.0.1.1.dist-info/RECORD,,