bosdyn-client 5.0.1.2__py3-none-any.whl → 5.1.1__py3-none-any.whl

bosdyn/client/log_status.py

@@ -12,11 +12,13 @@ This allows client code to start, extend or terminate experiment logs and start
 """
 
 import collections
+import re
+import time
 
 import bosdyn.util
 from bosdyn.api.log_status import log_status_pb2 as log_status
 from bosdyn.api.log_status import log_status_service_pb2_grpc as log_status_service
-from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,
+from bosdyn.client.common import (BaseClient, error_factory, error_pair,
                                   handle_common_header_errors, handle_unset_status_error)
 from bosdyn.client.exceptions import ResponseError
 
@@ -41,6 +43,10 @@ class ConcurrencyLimitReachedError(LogStatusResponseError):
     """The limit of concurrent retro logs has be reached, a new log cannot be started."""
 
 
+class NoDataForEventError(LogStatusResponseError):
+    """No data is available for the provided event, so a log cannot be started."""
+
+
 class LogStatusClient(BaseClient):
     """A client for interacting with robot logs."""
     # Typical name of the service in the robot's directory listing.
@@ -88,7 +94,7 @@ class LogStatusClient(BaseClient):
                                error_from_response=get_active_log_statuses_error,
                                copy_request=False, **kwargs)
 
-    def start_experiment_log(self, seconds, **kwargs):
+    def start_experiment_log(self, seconds, past_textlog_duration=0, **kwargs):
         """Start an experiment log, to run for a specified duration.
 
         Args:
@@ -99,14 +105,16 @@ class LogStatusClient(BaseClient):
         """
         req = log_status.StartExperimentLogRequest()
         req.keep_alive.CopyFrom(bosdyn.util.seconds_to_duration(seconds))
+        req.past_textlog_duration.CopyFrom(bosdyn.util.seconds_to_duration(past_textlog_duration))
         return self.call(self._stub.StartExperimentLog, req,
                          error_from_response=start_experiment_log_error, copy_request=False,
                          **kwargs)
 
-    def start_experiment_log_async(self, seconds, **kwargs):
+    def start_experiment_log_async(self, seconds, past_textlog_duration=0, **kwargs):
         """Start an experiment log, to run for a specified duration."""
         req = log_status.StartExperimentLogRequest()
         req.keep_alive.CopyFrom(bosdyn.util.seconds_to_duration(seconds))
+        req.past_textlog_duration.CopyFrom(bosdyn.util.seconds_to_duration(past_textlog_duration))
         return self.call_async(self._stub.StartExperimentLog, req,
                                error_from_response=start_experiment_log_error, copy_request=False,
                                **kwargs)
@@ -135,6 +143,31 @@ class LogStatusClient(BaseClient):
                                error_from_response=start_retro_log_error, copy_request=False,
                                **kwargs)
 
+    def start_concurrent_log(self, duration_seconds, event=None, **kwargs):
+        """Start an experiment log that allows concurrency, to run based on a particular data_set, as derived from the recipe corresponding to the provided event. An event must be provided!"""
+        req = log_status.StartConcurrentLogRequest()
+        req.keep_alive.CopyFrom(bosdyn.util.seconds_to_duration(duration_seconds))
+
+        if event:
+            req.event.CopyFrom(event)
+
+        return self.call(self._stub.StartConcurrentLog, req,
+                         error_from_response=start_concurrent_log_error, copy_request=False,
+                         **kwargs)
+
+    def start_concurrent_log_async(self, duration_seconds, data_set_names=None, properties=None,
+                                   event=None, **kwargs):
+        """Start an experiment log that allows concurrency, to run based on a particular data_set, as derived from the recipe corresponding to the provided event. An event must be provided!"""
+        req = log_status.StartConcurrentLogRequest()
+        req.keep_alive.CopyFrom(bosdyn.util.seconds_to_duration(duration_seconds))
+
+        if event:
+            req.event.CopyFrom(event)
+
+        return self.call_async(self._stub.StartConcurrentLog, req,
+                               error_from_response=start_concurrent_log_error, copy_request=False,
+                               **kwargs)
+
     def update_experiment(self, id, seconds, **kwargs):
         """Update an experiment log to run for a specified duration.
 
@@ -217,6 +250,18 @@ _START_RETRO_LOG_STATUS_TO_ERROR.update({
         error_pair(ConcurrencyLimitReachedError),
 })
 
+_START_CONCURRENT_LOG_STATUS_TO_ERROR = \
+    collections.defaultdict(lambda: (LogStatusResponseError, None))
+_START_CONCURRENT_LOG_STATUS_TO_ERROR.update({
+    log_status.StartConcurrentLogResponse.STATUS_OK: (None, None),
+    log_status.StartConcurrentLogResponse.STATUS_EXPERIMENT_LOG_RUNNING:
+        error_pair(ExperimentAlreadyRunningError),
+    log_status.StartConcurrentLogResponse.STATUS_CONCURRENCY_LIMIT_REACHED:
+        error_pair(ConcurrencyLimitReachedError),
+    log_status.StartConcurrentLogResponse.STATUS_NO_DATA_FOR_EVENT:
+        error_pair(NoDataForEventError),
+})
+
 _UPDATE_EXPERIMENT_LOG_STATUS_TO_ERROR = \
     collections.defaultdict(lambda: (LogStatusResponseError, None))
 _UPDATE_EXPERIMENT_LOG_STATUS_TO_ERROR.update({
@@ -272,6 +317,15 @@ def start_retro_log_error(response):
                          status_to_error=_START_RETRO_LOG_STATUS_TO_ERROR)
 
 
+@handle_common_header_errors
+@handle_unset_status_error(unset='STATUS_UNKNOWN')
+def start_concurrent_log_error(response):
+    """Return a custom exception based on the StartConcurrentLog response, None if no error."""
+    return error_factory(response, response.status,
+                         status_to_string=log_status.StartConcurrentLogResponse.Status.Name,
+                         status_to_error=_START_CONCURRENT_LOG_STATUS_TO_ERROR)
+
+
 @handle_common_header_errors
 @handle_unset_status_error(unset='STATUS_UNKNOWN')
 def update_experiment_log_error(response):

bosdyn/client/map_processing.py

@@ -6,11 +6,9 @@
 
 """For clients of the graph_nav map processing service."""
 
-from bosdyn.api.graph_nav import map_pb2, map_processing_pb2, map_processing_service_pb2
+from bosdyn.api.graph_nav import map_processing_pb2
 from bosdyn.api.graph_nav import map_processing_service_pb2_grpc as map_processing
-from bosdyn.client.common import (BaseClient, common_header_errors, error_factory,
-                                  handle_common_header_errors, handle_lease_use_result_errors,
-                                  handle_unset_status_error)
+from bosdyn.client.common import BaseClient, handle_common_header_errors, handle_unset_status_error
 from bosdyn.client.exceptions import ResponseError
 
 

bosdyn/client/network_compute_bridge_client.py

@@ -8,12 +8,10 @@
 
 import collections
 
-from bosdyn.api import (network_compute_bridge_pb2, network_compute_bridge_service_pb2,
-                        network_compute_bridge_service_pb2_grpc)
-from bosdyn.client.common import (BaseClient, error_factory, error_pair,
-                                  handle_common_header_errors, handle_custom_params_errors,
-                                  handle_lease_use_result_errors, handle_unset_status_error)
-from bosdyn.client.exceptions import Error, InternalServerError, ResponseError, UnsetStatusError
+from bosdyn.api import network_compute_bridge_pb2, network_compute_bridge_service_pb2_grpc
+from bosdyn.client.common import (BaseClient, error_pair, handle_common_header_errors,
+                                  handle_custom_params_errors)
+from bosdyn.client.exceptions import ResponseError, UnsetStatusError
 
 
 class ExternalServiceNotFoundError(ResponseError):

bosdyn/client/payload.py

@@ -11,7 +11,6 @@ This allows client code to read from the robot payload registry.
 
 import logging
 
-import bosdyn.api.payload_pb2 as payload_protos
 import bosdyn.api.payload_pb2 as payload_service_protos
 import bosdyn.api.payload_service_pb2_grpc as payload_service
 
@@ -38,7 +37,7 @@ class PayloadClient(BaseClient):
 
         Args:
           kw_args:              Extra arguments to pass to grpc call invocation.
-        
+
         Returns:
           A list of the proto message definitions of all registered payloads
 
@@ -54,7 +53,7 @@ class PayloadClient(BaseClient):
 
         Args:
           kw_args:              Extra arguments to pass to grpc call invocation.
-        
+
         Returns:
           A list of the proto message definitions of all registered payloads
 

bosdyn/client/payload_registration.py

@@ -19,8 +19,9 @@ import bosdyn.api.payload_registration_service_pb2_grpc as payload_registration_
 from bosdyn.client import (ResponseError, RetryableUnavailableError, TimedOutError,
                            TooManyRequestsError)
 from bosdyn.client.common import (BaseClient, error_factory, handle_common_header_errors,
-                                  handle_lease_use_result_errors, handle_unset_status_error)
+                                  handle_unset_status_error)
 from bosdyn.client.error_callback_result import ErrorCallbackResult
+from bosdyn.util import now_sec
 
 LOGGER = logging.getLogger('payload_registration_client')
 
@@ -156,7 +157,7 @@ class PayloadRegistrationClient(BaseClient):
 
     def get_payload_auth_token(self, guid, secret, **kw_args):
         """Request a limited-access auth token for a payload.
-        
+
         Getting the auth token requires payload to be authorized via the web console.
 
         Args:
@@ -166,7 +167,7 @@ class PayloadRegistrationClient(BaseClient):
 
         Returns:
           A limited-access user token for the robot
-        
+
         Raises:
           RpcError: Problem communicating with the robot.
           PayloadNotAuthorizedError: The payload with the provided GUID is
@@ -370,7 +371,7 @@ class PayloadRegistrationKeepAlive(object):
     the robot if it is ever forgotten. However, payload registrations on Spot are persistent
     across power cycles and updates, so in most cases there is no need to send a payload
     registration request after the first successful payload registration. The use of a payload
-    registration keep alive should only be used when a payload is expected to be regularly 
+    registration keep alive should only be used when a payload is expected to be regularly
     reconfigured by forgetting & re-authorizing the payload in the web page.
 
     Args:
@@ -413,9 +414,9 @@ class PayloadRegistrationKeepAlive(object):
 
     def start(self):
         """Register and then kick off thread.
-        
+
         Can not be restarted with this method after a shutdown.
-        
+
         Raises:
           RpcError: Problem communicating with the robot.
           RuntimeError: The thread was attempted to start more than once.
@@ -435,7 +436,7 @@ class PayloadRegistrationKeepAlive(object):
 
     def is_alive(self):
         """Are we still periodically re-registering?
-        
+
         Returns:
           A bool stating if still alive
         """
@@ -449,7 +450,7 @@ class PayloadRegistrationKeepAlive(object):
 
     def _periodic_reregister(self):
         """Handles a removal of the payload from the robot payload page while still connected.
-        
+
         Raises:
           RpcError: Problem communicating with the robot.
         """
@@ -458,7 +459,7 @@ class PayloadRegistrationKeepAlive(object):
         wait_time = self._registration_interval_secs
 
         while not self._end_reregister_signal.wait(wait_time):
-            exec_start = time.time()
+            exec_start = now_sec()
             action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
             try:
                 self.pay_reg_client.register_payload(self.payload, self.secret)
@@ -486,7 +487,7 @@ class PayloadRegistrationKeepAlive(object):
                     # 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
+            exec_sec = now_sec() - exec_start
             if action == ErrorCallbackResult.ABORT:
                 self.logger.warning('Callback directed the re-registration loop to exit.')
                 break

bosdyn/client/power.py

@@ -13,13 +13,14 @@ from concurrent.futures import TimeoutError
 from deprecated.sphinx import deprecated
 from google.protobuf.duration_pb2 import Duration
 
-from bosdyn.api import (basic_command_pb2, full_body_command_pb2, license_pb2, power_pb2,
-                        power_service_pb2_grpc, robot_command_pb2, robot_state_pb2)
+from bosdyn.api import (basic_command_pb2, full_body_command_pb2, power_pb2, power_service_pb2_grpc,
+                        robot_command_pb2, robot_state_pb2)
 from bosdyn.client.common import (BaseClient, common_license_errors, error_factory,
                                   handle_common_header_errors, handle_lease_use_result_errors,
                                   handle_unset_status_error)
 from bosdyn.client.exceptions import (Error, InternalServerError, LicenseError, ResponseError,
                                       TimedOutError)
+from bosdyn.util import now_sec
 
 from .lease import add_lease_wallet_processors
 
@@ -82,9 +83,10 @@ class SafetyStopUnknownStopTypeError(PowerResponseError):
 
 class PowerClient(BaseClient):
     """A client for enabling / disabling robot motor power.
+
     Commands are non-blocking. Clients are expected to issue a power command and then periodically
-    check the status of this command.
-    This service requires ownership over the robot, in the form of a lease.
+    check the status of this command. This service requires ownership over the robot, in the form of
+    a lease.
     """
     default_service_name = 'power'
     service_type = 'bosdyn.api.PowerService'
@@ -134,7 +136,7 @@ class PowerClient(BaseClient):
                                _fan_power_command_error_from_response, **kwargs)
 
     def fan_power_command_feedback(self, command_id, **kwargs):
-        """Check the status of a previously issued fan command"""
+        """Check the status of a previously issued fan command."""
         req = self._fan_power_command_feedback_request(command_id)
         return self.call(self._stub.FanPowerCommandFeedback, req, None,
                          _fan_power_feedback_error_from_response, **kwargs)
@@ -190,7 +192,10 @@ def _handle_license_errors(func):
 
 
 def _common_license_errors(response):
-    """Return an exception based on license status. None if no error."""
+    """Return an exception based on license status.
+
+    None if no error.
+    """
     if response.status != power_pb2.STATUS_LICENSE_ERROR:
         return None
 
@@ -284,14 +289,17 @@ _RESET_SAFETY_STOP_STATUS_TO_ERROR.update({
 @deprecated(reason='Replaced by the less ambiguous safe_power_off_motors function.',
             version='3.0.0', action="ignore")
 def safe_power_off(command_client, state_client, timeout_sec=30, update_frequency=1.0, **kwargs):
-    """Safely power off motors. See safe_power_off_motors()."""
+    """Safely power off motors.
+
+    See safe_power_off_motors().
+    """
     safe_power_off_motors(command_client, state_client, timeout_sec, update_frequency, **kwargs)
 
 
 def safe_power_off_motors(command_client, state_client, timeout_sec=30, update_frequency=1.0,
                           **kwargs):
-    """Power off robot motors safely. This function blocks until robot safely powers off. This
-    means the robot will attempt to sit before powering motors off.
+    """Power off robot motors safely. This function blocks until robot safely powers off. This means
+    the robot will attempt to sit before powering motors off.
 
     Args:
         command_client (RobotCommandClient): client for calling RobotCommandService safe power off.
@@ -305,7 +313,7 @@ def safe_power_off_motors(command_client, state_client, timeout_sec=30, update_f
         power.CommandTimedOutError: Did not power off within timeout_sec
         RobotCommandResponseError: Something went wrong with the safe power off.
     """
-    start_time = time.time()
+    start_time = now_sec()
     end_time = start_time + timeout_sec
     update_time = 1.0 / update_frequency
 
@@ -314,9 +322,9 @@ def safe_power_off_motors(command_client, state_client, timeout_sec=30, update_f
     command = robot_command_pb2.RobotCommand(full_body_command=full_body_command)
     command_client.robot_command(command=command, **kwargs)
 
-    while time.time() < end_time:
-        time_until_timeout = end_time - time.time()
-        start_call_time = time.time()
+    while now_sec() < end_time:
+        time_until_timeout = end_time - now_sec()
+        start_call_time = now_sec()
         future = state_client.get_robot_state_async(**kwargs)
         try:
             response = future.result(timeout=time_until_timeout)
@@ -324,7 +332,7 @@ def safe_power_off_motors(command_client, state_client, timeout_sec=30, update_f
                 return
         except TimeoutError:
             raise CommandTimedOutError
-        call_time = time.time() - start_call_time
+        call_time = now_sec() - start_call_time
         sleep_time = max(0.0, update_time - call_time)
         time.sleep(sleep_time)
     raise CommandTimedOutError
@@ -333,14 +341,20 @@ def safe_power_off_motors(command_client, state_client, timeout_sec=30, update_f
 @deprecated(reason='Replaced by the less ambiguous power_on_motors function.', version='2.3.4',
             action="ignore")
 def power_on(power_client, timeout_sec=30, update_frequency=1.0, **kwargs):
-    """Power on robot motors. See power_on_motors()."""
+    """Power on robot motors.
+
+    See power_on_motors().
+    """
     power_on_motors(power_client, timeout_sec, update_frequency, **kwargs)
 
 
 @deprecated(reason='Replaced by the less ambiguous power_off_motors function.', version='2.3.4',
             action="ignore")
 def power_off(power_client, timeout_sec=30, update_frequency=1.0, **kwargs):
-    """Power off the robot motors. See power_off_motors()."""
+    """Power off the robot motors.
+
+    See power_off_motors().
+    """
     power_off_motors(power_client, timeout_sec, update_frequency, **kwargs)
 
 
@@ -399,10 +413,10 @@ def safe_power_off_robot(command_client, state_client, power_client, timeout_sec
         power.CommandTimedOutError: Did not power off within timeout_sec
         RobotCommandResponseError: Something went wrong with the safe power off.
     """
-    end_time = time.time() + timeout_sec
-    safe_power_off_motors(command_client, state_client, timeout_sec=end_time - time.time(),
+    end_time = now_sec() + timeout_sec
+    safe_power_off_motors(command_client, state_client, timeout_sec=end_time - now_sec(),
                           update_frequency=update_frequency, **kwargs)
-    power_off_robot(power_client, timeout_sec=end_time - time.time(),
+    power_off_robot(power_client, timeout_sec=end_time - now_sec(),
                     update_frequency=update_frequency, **kwargs)
 
 
@@ -442,10 +456,10 @@ def safe_power_cycle_robot(command_client, state_client, power_client, timeout_s
         power.CommandTimedOutError: Did not power off within timeout_sec
         RobotCommandResponseError: Something went wrong with the safe power off.
     """
-    end_time = time.time() + timeout_sec
-    safe_power_off_motors(command_client, state_client, timeout_sec=end_time - time.time(),
+    end_time = now_sec() + timeout_sec
+    safe_power_off_motors(command_client, state_client, timeout_sec=end_time - now_sec(),
                           update_frequency=update_frequency, **kwargs)
-    power_cycle_robot(power_client, timeout_sec=end_time - time.time(),
+    power_cycle_robot(power_client, timeout_sec=end_time - now_sec(),
                       update_frequency=update_frequency, **kwargs)
 
 
@@ -467,6 +481,49 @@ def power_cycle_robot(power_client, timeout_sec=30, update_frequency=1.0, **kwar
                    **kwargs)
 
 
+def safe_soft_reboot_robot(command_client, state_client, power_client, timeout_sec=30,
+                           update_frequency=1.0, **kwargs):
+    """Soft reboot the robot safely. This function blocks until robot safely powers off. The robot
+    will attempt to sit before soft rebooting.
+
+    Args:
+        command_client (RobotCommandClient): client for calling RobotCommandService safe power off.
+        state_client (RobotStateClient): client for monitoring power state.
+        power_client (bosdyn.api.PowerClient): client for calling power service.
+        timeout_sec (float): Max time this function will block for.
+        update_frequency (float): The frequency with which the robot should check if the command
+                                  has succeeded.
+
+    Raises:
+        RpcError: Problem communicating with the robot.
+        power.CommandTimedOutError: Did not power off within timeout_sec
+        RobotCommandResponseError: Something went wrong with the safe power off.
+    """
+    end_time = now_sec() + timeout_sec
+    safe_power_off_motors(command_client, state_client, timeout_sec=end_time - now_sec(),
+                          update_frequency=update_frequency, **kwargs)
+    soft_reboot_robot(power_client, timeout_sec=end_time - now_sec(),
+                      update_frequency=update_frequency, **kwargs)
+
+
+def soft_reboot_robot(power_client, timeout_sec=30, update_frequency=1.0, **kwargs):
+    """Soft reboot the robot. Rebooting the robot will stop API comms.
+
+    Args:
+        power_client (bosdyn.api.PowerClient): client for calling power service.
+        timeout_sec (float): Max time this function will block for.
+        update_frequency (float): The frequency with which the robot should check if the command
+                                  has succeeded.
+    Raises:
+        RpcError: Problem communicating with the robot.
+        power.CommandTimedOutError: Did not power off within timeout_sec
+        PowerResponseError: Something went wrong during the power off sequence.
+    """
+    request = power_pb2.PowerCommandRequest.REQUEST_SOFT_REBOOT_ROBOT
+    _power_command(power_client, request, timeout_sec, update_frequency, expect_grpc_timeout=True,
+                   **kwargs)
+
+
 def power_off_payload_ports(power_client, timeout_sec=30, update_frequency=1.0, **kwargs):
     """Power off the robot payload ports.
 
@@ -551,7 +608,7 @@ def _power_command(power_client, request, timeout_sec=30, update_frequency=1.0,
                                   has succeeded.
         expect_timeout (bool): Expect API comms to drop on a success.
     """
-    start_time = time.time()
+    start_time = now_sec()
     end_time = start_time + timeout_sec
     update_time = 1.0 / update_frequency
 
@@ -566,9 +623,9 @@ def _power_command(power_client, request, timeout_sec=30, update_frequency=1.0,
         return  # Command succeeded immediately.
 
     power_command_id = response.power_command_id
-    while time.time() < end_time:
-        time_until_timeout = end_time - time.time()
-        start_call_time = time.time()
+    while now_sec() < end_time:
+        time_until_timeout = end_time - now_sec()
+        start_call_time = now_sec()
         future = power_client.power_command_feedback_async(power_command_id, **kwargs)
         try:
             response = future.result(timeout=time_until_timeout)
@@ -585,7 +642,7 @@ def _power_command(power_client, request, timeout_sec=30, update_frequency=1.0,
                 raise
         except TimeoutError:
             raise CommandTimedOutError
-        call_time = time.time() - start_call_time
+        call_time = now_sec() - start_call_time
         sleep_time = max(0.0, update_time - call_time)
         time.sleep(sleep_time)
     raise CommandTimedOutError

bosdyn/client/processors.py

@@ -25,11 +25,36 @@ class AddRequestHeader(object):
 
     def mutate(self, request):
         """Mutate request such that its header contains a client name and a timestamp.
-        
+
         Headers are not required for third party proto requests/responses.
         """
         header = self._create_header()
         try:
             request.header.CopyFrom(header)
         except AttributeError:
-            pass
+            pass
+
+
+class DataBufferLoggingProcessor:
+    """Processor that logs every protobuf message to the robot's data buffer."""
+
+    def __init__(self, data_buffer_client):
+        """
+        Args:
+            data_buffer_client: Instance of DataBufferClient.
+        """
+        self.data_buffer_client = data_buffer_client
+
+    def mutate(self, proto, **kwargs):
+        """Logs the protobuf message to the data buffer.
+        Args:
+            proto: The protobuf request or response to log.
+        """
+        self.data_buffer_client.add_protobuf_async(proto)
+
+
+def log_all_rpcs(client, data_buffer_client):
+    """Attach a DataBufferLoggingProcessor to log all RPC requests and responses for the given client."""
+    processor = DataBufferLoggingProcessor(data_buffer_client)
+    client.request_processors.append(processor)
+    client.response_processors.append(processor)

bosdyn/client/recording.py

@@ -9,11 +9,11 @@
 import collections
 from enum import Enum
 
-from bosdyn.api.graph_nav import map_pb2, nav_pb2, recording_pb2, recording_service_pb2
+from bosdyn.api.graph_nav import map_pb2, recording_pb2
 from bosdyn.api.graph_nav import recording_service_pb2_grpc as recording_service
 from bosdyn.client.common import (BaseClient, common_header_errors, error_factory,
-                                  handle_common_header_errors, handle_lease_use_result_errors,
-                                  handle_license_errors_if_present, handle_unset_status_error)
+                                  handle_common_header_errors, handle_license_errors_if_present,
+                                  handle_unset_status_error)
 from bosdyn.client.exceptions import ResponseError