bosdyn-client 4.1.1__py3-none-any.whl → 5.0.1__py3-none-any.whl

bosdyn/client/__init__.py

@@ -22,3 +22,4 @@ from .exceptions import (ClientCancelledOperationError, CustomParamError, Error,
 from .robot import Robot
 from .sdk import BOSDYN_RESOURCE_ROOT, Sdk, create_standard_sdk
 
+

bosdyn/client/audio_visual.py

@@ -0,0 +1,339 @@
+# 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 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
+
+
+
+_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)
+})
+
+
+
+@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)
+
+

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/command_line.py

@@ -4,6 +4,8 @@
 # is subject to the terms and conditions of the Boston Dynamics Software
 # Development Kit License (20191101-BDSDK-SL).
 
+# Boston Dynamics, Inc. Confidential Information.
+# Copyright 2025. All Rights Reserved.
 """Command-line utility code for interacting with robot services."""
 
 from __future__ import division
@@ -705,13 +707,16 @@ class LogStatusCommands(Subcommands):
             subparsers: List of argument parsers.
             command_dict: Dictionary of command names which take parsed options.
         """
-        super(LogStatusCommands, self).__init__(subparsers, command_dict, [
-            GetLogCommand,
-            GetActiveLogStatusesCommand,
-            ExperimentLogCommand,
-            StartRetroLogCommand,
-            TerminateLogCommand,
-        ])
+        super(LogStatusCommands, self).__init__(
+            subparsers,
+            command_dict,
+            [
+                GetLogCommand,
+                GetActiveLogStatusesCommand,
+                ExperimentLogCommand,
+                StartRetroLogCommand,
+                TerminateLogCommand,
+            ])
 
 
 class GetLogCommand(Command):
@@ -947,6 +952,8 @@ class TerminateLogCommand(Command):
         return True
 
 
+
+
 class RobotIdCommand(Command):
     """Show robot-id."""
 
@@ -2646,6 +2653,7 @@ def main(args=None):
     parser = argparse.ArgumentParser(prog='bosdyn.client', description=main.__doc__)
     add_common_arguments(parser, credentials_no_warn=True)
 
+
     command_dict = {}  # command name to fn which takes parsed options
     subparsers = parser.add_subparsers(title='commands', dest='command')
 

bosdyn/client/data_acquisition_helpers.py

@@ -167,7 +167,7 @@ def clean_filename(filename):
         filename(string): Original filename to clean.
 
     Returns:
-        Valid filename with removed characters :*?<>|
+        Valid filename with removed characters :?<>|*
     """
 
     return "".join(i for i in filename if i not in ":*?<>|")

bosdyn/client/data_acquisition_store.py

@@ -338,8 +338,8 @@ class DataAcquisitionStoreClient(BaseClient):
     def query_max_capture_id(self, **kwargs):
         """Query max capture id from the robot.
         Returns:
-            QueryMaxCaptureIdResult, which has a max_capture_id uint64, corresponding to the 
-            greatest capture id on the robot.  Used for skiping DAQ synchronization
+            QueryMaxCaptureIdResult, which has a max_capture_id uint64, corresponding to the
+            greatest capture id on the robot.  Used for skipping DAQ synchronization
             on connect.
         """
         request = data_acquisition_store.QueryMaxCaptureIdRequest()

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