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

bosdyn/client/gps/gps_listener.py

@@ -11,15 +11,13 @@ import socket
 import time
 from typing import List
 
-import bosdyn.api
-import bosdyn.client.util
 from bosdyn.api.gps.gps_pb2 import GpsDataPoint, GpsDevice
 from bosdyn.client.exceptions import ProxyConnectionError
 from bosdyn.client.gps.aggregator_client import AggregatorClient
 from bosdyn.client.gps.NMEAParser import NMEAParser
 from bosdyn.client.gps.ntrip_client import NtripClient, NtripClientParams
 from bosdyn.client.robot import UnregisteredServiceNameError
-from bosdyn.util import RobotTimeConverter, duration_to_seconds
+from bosdyn.util import RobotTimeConverter, now_sec
 
 
 class NMEAStreamReader(object):
@@ -44,7 +42,7 @@ class NMEAStreamReader(object):
                 raw_data = str(raw_data, "utf-8")
         except UnicodeDecodeError:
             # Throttle the logs.
-            now = time.time()
+            now = now_sec()
             if self.last_failed_read_log_time is None or (
                     now - self.last_failed_read_log_time) > self.LOG_THROTTLE_TIME:
                 self.logger.exception("Failed to decode NMEA message. Is it not Unicode?")
@@ -160,17 +158,17 @@ class GpsListener:
                         agg_future = self.aggregator_client.new_gps_data_async(
                             accumulated_data, self.gps_device)
                         accumulated_data.clear()
-                        timestamp_of_last_rpc = time.time()
+                        timestamp_of_last_rpc = now_sec()
                         time_passed_since_last_rpc = 0
                 else:
                     if time_passed_since_last_rpc > every_x_seconds:
                         if agg_future is None or agg_future.done():
                             agg_future = self.aggregator_client.new_gps_data_async([],
                                                                                    self.gps_device)
-                        timestamp_of_last_rpc = time.time()
+                        timestamp_of_last_rpc = now_sec()
                         time_passed_since_last_rpc = 0
                     else:
-                        time_passed_since_last_rpc = time.time() - timestamp_of_last_rpc
+                        time_passed_since_last_rpc = now_sec() - timestamp_of_last_rpc
 
                 # If we are running an NTRIP client, pass it the latest GGA message.
                 if self.ntrip_client is not None:

bosdyn/client/gps/ntrip_client.py

@@ -25,7 +25,7 @@ class NtripClientParams:
     """
 
     def __init__(self, server=DEFAULT_NTRIP_SERVER, port=DEFAULT_NTRIP_PORT, user="", password="",
-                 mountpoint="", tls=False):
+                 mountpoint="", tls=False, reconnect_secs=SERVER_RECONNECT_DELAY):
         """
         Constructor.
         """
@@ -35,6 +35,7 @@ class NtripClientParams:
         self.password = password
         self.mountpoint = mountpoint
         self.tls = tls
+        self.reconnect_secs = reconnect_secs
 
 
 class NtripClient:
@@ -54,6 +55,7 @@ class NtripClient:
         self.password = params.password
         self.mountpoint = params.mountpoint
         self.tls = params.tls
+        self.reconnect_secs = params.reconnect_secs
 
         self.thread = None
         self.streaming = False
@@ -143,9 +145,9 @@ class NtripClient:
             self.logger.info(response_lines[0].decode())
             if status[1] != "200":
                 self.logger.error("HTTP Error: %s, retrying in %d seconds",
-                                  response_lines[0].decode(), SERVER_RECONNECT_DELAY)
+                                  response_lines[0].decode(), self.reconnect_secs)
                 sock.close()
-                time.sleep(SERVER_RECONNECT_DELAY)
+                time.sleep(self.reconnect_secs)
                 return False
             self.logger.info("NTRIP Request Response received.")
             for line in range(1, len(response_lines)):
@@ -218,6 +220,13 @@ class NtripClient:
         self.streaming = True
         while self.streaming:
             self.stream_data()
+            # stream_data blocks for the lifetime of a connection. If it returns while we are still
+            # expecting to be streaming, it means the server disconnected from us. Wait for a delay
+            # before attempting to reconnect to avoid spamming the server.
+            if self.streaming:
+                self.logger.info(
+                    f"Attempting to reconnect to NTRIP server in {self.reconnect_secs} seconds.")
+                time.sleep(self.reconnect_secs)
 
     def handle_ntrip_data(self, data):
         """

bosdyn/client/graph_nav.py

@@ -13,14 +13,14 @@ import time
 from deprecated.sphinx import deprecated
 
 from bosdyn.api import data_chunk_pb2, lease_pb2
-from bosdyn.api.graph_nav import (graph_nav_pb2, graph_nav_service_pb2, graph_nav_service_pb2_grpc,
-                                  map_pb2, nav_pb2)
+from bosdyn.api.graph_nav import graph_nav_pb2, graph_nav_service_pb2_grpc, map_pb2, nav_pb2
 from bosdyn.client.common import (BaseClient, common_header_errors, common_lease_errors,
                                   error_factory, error_pair, handle_common_header_errors,
                                   handle_lease_use_result_errors, handle_license_errors_if_present,
                                   handle_unset_status_error)
-from bosdyn.client.exceptions import Error, InvalidRequestError, ResponseError, UnimplementedError
+from bosdyn.client.exceptions import ResponseError, UnimplementedError
 from bosdyn.client.lease import add_lease_wallet_processors
+from bosdyn.util import now_sec
 
 
 class GraphNavClient(BaseClient):
@@ -476,13 +476,15 @@ class GraphNavClient(BaseClient):
                                error_from_response=handle_common_header_errors(common_lease_errors),
                                copy_request=False, **kwargs)
 
-    def upload_graph(self, lease=None, graph=None, generate_new_anchoring=False, **kwargs):
+    def upload_graph(self, lease=None, graph=None, generate_new_anchoring=False,
+                     replace_graph=False, **kwargs):
         """Uploads a graph to the server and appends to the existing graph.
 
         Args:
             lease: Leases to show ownership of necessary resources. Will use the client's leases by default.
             graph: Graph protobuf that represents the map with waypoints and edges.
             generate_new_anchoring: Whether to generate an (overwrite the) anchoring on upload.
+            replace_graph: If true, replaces the existing graph with the new one rather than adding to it.
         Returns:
             The response, which includes waypoint and edge id's sorted by whether it was cached.
         Raises:
@@ -493,7 +495,8 @@ class GraphNavClient(BaseClient):
             LeaseUseError: Error using provided lease.
             LicenseError: The robot's license is not valid.
         """
-        request = self._build_upload_graph_request(lease, graph, generate_new_anchoring)
+        request = self._build_upload_graph_request(lease, graph, generate_new_anchoring,
+                                                   replace_graph)
         # Use streaming to upload the graph, if applicable.
         if self._use_streaming_graph_upload:
             # Need to manually apply request processors since this will be serialized and chunked.
@@ -509,14 +512,17 @@ class GraphNavClient(BaseClient):
             except UnimplementedError:
                 print('UploadGraphStreaming unimplemented. Old robot release?')
                 # Recreate the request so that we clear any state that might have happened during our attempt to stream.
-                request = self._build_upload_graph_request(lease, graph, generate_new_anchoring)
+                request = self._build_upload_graph_request(lease, graph, generate_new_anchoring,
+                                                           replace_graph)
                 # Continue to regular UploadGraph.
         return self.call(self._stub.UploadGraph, request, value_from_response=_get_response,
                          error_from_response=_upload_graph_error, copy_request=False, **kwargs)
 
-    def upload_graph_async(self, lease=None, graph=None, generate_new_anchoring=False, **kwargs):
+    def upload_graph_async(self, lease=None, graph=None, generate_new_anchoring=False,
+                           replace_graph=False, **kwargs):
         """Async version of upload_graph()."""
-        request = self._build_upload_graph_request(lease, graph, generate_new_anchoring)
+        request = self._build_upload_graph_request(lease, graph, generate_new_anchoring,
+                                                   replace_graph)
         return self.call_async(self._stub.UploadGraph, request, value_from_response=_get_response,
                                error_from_response=_upload_graph_error, copy_request=False,
                                **kwargs)
@@ -562,6 +568,32 @@ class GraphNavClient(BaseClient):
             value_from_response=None,
             error_from_response=handle_common_header_errors(common_lease_errors), **kwargs)
 
+    def upload_snapshots(self, snapshots, lease=None, **kwargs):
+        """Uploads multiple snapshots as a stream.
+
+        graph_nav only processes complete Snapshots so large protos are discouraged;
+        any network interruption would require the data to be resent.  Clients are
+        encouraged to send data in batches on the order of a few MB to strike a
+        balance between eliminating per-RPC overhead and recovering from errors.
+
+        Args:
+            lease: Leases to show ownership of necessary resources. Will use the client's leases by default.
+            snapshots: UploadSnapshotsRequest.Snapshots protobuf that will be stream-uploaded to the robot.
+        Returns:
+            The status of the upload request.
+        Raises:
+            RpcError: Problem communicating with the robot.
+            LeaseUseError: Error using provided leases.
+        """
+        lease = lease or lease_pb2.Lease()
+        serialized = snapshots.SerializeToString()
+        self.call(
+            self._stub.UploadSnapshots,
+            GraphNavClient._data_chunk_iterator_upload_snapshots(serialized, lease,
+                                                                 self._data_chunk_size),
+            value_from_response=None,
+            error_from_response=handle_common_header_errors(common_lease_errors), **kwargs)
+
     def download_graph(self, **kwargs):
         """Downloads the graph from the server.
 
@@ -724,7 +756,7 @@ class GraphNavClient(BaseClient):
         if travel_params is not None:
             request.travel_params.CopyFrom(travel_params)
         request.end_time.CopyFrom(
-            converter.robot_timestamp_from_local_secs(time.time() + end_time_secs))
+            converter.robot_timestamp_from_local_secs(now_sec() + end_time_secs))
         if command_id is not None:
             request.command_id = command_id
         return request
@@ -739,7 +771,7 @@ class GraphNavClient(BaseClient):
             destination_waypoint_tform_body_goal=destination_waypoint_tform_body_goal,
             clock_identifier=timesync_endpoint.clock_identifier)
         request.end_time.CopyFrom(
-            converter.robot_timestamp_from_local_secs(time.time() + end_time_secs))
+            converter.robot_timestamp_from_local_secs(now_sec() + end_time_secs))
         if travel_params is not None:
             request.travel_params.CopyFrom(travel_params)
         if route_params is not None:
@@ -764,7 +796,7 @@ class GraphNavClient(BaseClient):
         if gps_navigation_params:
             request.gps_navigation_params.CopyFrom(gps_navigation_params)
         request.end_time.CopyFrom(
-            converter.robot_timestamp_from_local_secs(time.time() + end_time_secs))
+            converter.robot_timestamp_from_local_secs(now_sec() + end_time_secs))
         if travel_params is not None:
             request.travel_params.CopyFrom(travel_params)
         if route_params is not None:
@@ -783,10 +815,11 @@ class GraphNavClient(BaseClient):
         return graph_nav_pb2.NavigationFeedbackRequest(command_id=command_id)
 
     @staticmethod
-    def _build_upload_graph_request(lease, graph, generate_new_anchoring):
+    def _build_upload_graph_request(lease, graph, generate_new_anchoring, replace_graph):
         lease = lease or lease_pb2.Lease()
         return graph_nav_pb2.UploadGraphRequest(lease=lease, graph=graph,
-                                                generate_new_anchoring=generate_new_anchoring)
+                                                generate_new_anchoring=generate_new_anchoring,
+                                                replace_graph=replace_graph)
 
     @staticmethod
     def _data_chunk_iterator_upload_graph(serialized_upload_graph, data_chunk_byte_size):
@@ -836,6 +869,27 @@ class GraphNavClient(BaseClient):
             req = graph_nav_pb2.UploadEdgeSnapshotRequest(lease=lease, chunk=chunk)
             yield req
 
+    @staticmethod
+    def _data_chunk_iterator_upload_snapshots(serialized_snapshots, lease, data_chunk_byte_size):
+        total_bytes_size = len(serialized_snapshots)
+        # If the snapshots are empty, still send one empty request.
+        # This is used to probe if the RPC is implemented.
+        if 0 == total_bytes_size:
+            req = graph_nav_pb2.UploadSnapshotsRequest(lease=lease)
+            yield req
+
+        num_chunks = math.ceil(total_bytes_size / data_chunk_byte_size)
+        for i in range(num_chunks):
+            start_index = i * data_chunk_byte_size
+            end_index = (i + 1) * data_chunk_byte_size
+            chunk = data_chunk_pb2.DataChunk(total_size=total_bytes_size)
+            if (end_index > total_bytes_size):
+                chunk.data = serialized_snapshots[start_index:total_bytes_size]
+            else:
+                chunk.data = serialized_snapshots[start_index:end_index]
+            req = graph_nav_pb2.UploadSnapshotsRequest(lease=lease, chunk=chunk)
+            yield req
+
     @staticmethod
     def _build_download_graph_request():
         return graph_nav_pb2.DownloadGraphRequest()

bosdyn/client/hazard_avoidance.py

@@ -0,0 +1,119 @@
+# 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).
+
+"""For clients to use the hazard_avoidance service"""
+
+import collections
+
+from bosdyn.api import hazard_avoidance_pb2
+from bosdyn.api import hazard_avoidance_service_pb2_grpc as hazard_avoidance_service
+from bosdyn.client.common import (BaseClient, custom_params_error, error_factory, error_pair,
+                                  handle_common_header_errors)
+from bosdyn.client.exceptions import InvalidRequestError, ResponseError, UnsetStatusError
+from bosdyn.client.robot_command import NoTimeSyncError
+from bosdyn.client.time_sync import update_timestamp_filter
+
+
+class AddHazardsResponseError(ResponseError):
+    """General class of errors for hazard avoidance service."""
+
+
+_ADD_HAZARD_STATUS_TO_ERROR = collections.defaultdict(lambda: (AddHazardsResponseError, None))
+_ADD_HAZARD_STATUS_TO_ERROR.update({
+    hazard_avoidance_pb2.AddHazardResult.STATUS_HAZARDS_UPDATED: (None, None),
+    hazard_avoidance_pb2.AddHazardResult.STATUS_IGNORED: (None, None),
+    hazard_avoidance_pb2.AddHazardResult.STATUS_INVALID_DATA: error_pair(InvalidRequestError),
+    hazard_avoidance_pb2.AddHazardResult.STATUS_UNKNOWN: error_pair(UnsetStatusError),
+})
+
+
+@handle_common_header_errors
+def _error_from_response(response):
+    """Return a custom exception based on the first invalid add hazard result, None if no error."""
+    for add_hazard_result in response.add_hazard_results:
+        result = custom_params_error(add_hazard_result, total_response=response)
+        if result is not None:
+            return result
+
+        result = error_factory(response, add_hazard_result.status,
+                               status_to_string=hazard_avoidance_pb2.AddHazardResult.Status.Name,
+                               status_to_error=_ADD_HAZARD_STATUS_TO_ERROR)
+        if result is not None:
+            # The exception is using the add hazards result.  Replace it with the full response.
+            result.response = response
+            return result
+    return None
+
+
+def _get_add_hazards_value(response):
+    return response.add_hazard_results
+
+
+class HazardAvoidanceClient(BaseClient):
+    """Client for Hazard avoidance service."""
+    default_service_name = 'hazard-avoidance-service'
+    service_type = 'bosdyn.api.HazardAvoidanceService'
+
+    def __init__(self):
+        super(HazardAvoidanceClient,
+              self).__init__(hazard_avoidance_service.HazardAvoidanceServiceStub)
+        self._timesync_endpoint = None
+
+    def update_from(self, other):
+        super(HazardAvoidanceClient, 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
+
+    @property
+    def timesync_endpoint(self):
+        """Accessor for timesync-endpoint that is grabbed via 'update_from()'.
+
+        Raises:
+            bosdyn.client.robot_command.NoTimeSyncError: Could not find the timesync endpoint for
+                the robot.
+        """
+        if not self._timesync_endpoint:
+            raise NoTimeSyncError("[world object service] No timesync endpoint set for the robot")
+        return self._timesync_endpoint
+
+    def add_hazards(self, add_hazards_req, **kwargs):
+        """Add hazards to the hazard map.
+
+        Args:
+            add_hazards_req (hazard_avoidance_pb2.AddHazardsRequest): The request including the hazard observations to add.
+        Returns:
+            response (hazard_avoidance_pb2.AddHazardsResponse): Contains the status of adding each observation,
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+            bosdyn.client.robot_command.NoTimeSyncError: Couldn't convert the timestamp into robot
+                time.
+            UnsetStatusError: An internal HazardAvoidanceService issue has happened.
+            AddHazardsResponseError: General problem with the request.
+            bosdyn.client.exceptions.InvalidRequestError: One or more hazard observations contained errors.
+        """
+        for hazard_obs in add_hazards_req.hazards:
+            if hazard_obs.HasField("acquisition_time"):
+                # Ensure the hazard observation's time of detection is in robot time.
+                client_timestamp = hazard_obs.acquisition_time
+                hazard_obs.acquisition_time.CopyFrom(
+                    update_timestamp_filter(self, client_timestamp, self.timesync_endpoint))
+        return self.call(self._stub.AddHazards, add_hazards_req, _get_add_hazards_value,
+                         _error_from_response, copy_request=False, **kwargs)
+
+    def add_hazards_async(self, add_hazards_req, **kwargs):
+        """Async version of add_hazards()."""
+        for hazard_obs in add_hazards_req.hazards:
+            if hazard_obs.HasField("acquisition_time"):
+                # Ensure the hazard observation's time of detection is in robot time.
+                client_timestamp = hazard_obs.acquisition_time
+                hazard_obs.acquisition_time.CopyFrom(
+                    update_timestamp_filter(self, client_timestamp, self.timesync_endpoint))
+        return self.call_async(self._stub.AddHazards, add_hazards_req, _get_add_hazards_value,
+                               _error_from_response, copy_request=False, **kwargs)

bosdyn/client/image.py

@@ -231,12 +231,13 @@ def write_pgm_or_ppm(image_response, filename="", filepath=".", include_pixel_fo
                             a filename ("image-{SOURCENAME}-{PIXELFORMAT}.pgm").
     """
     # Determine the data type to decode the image.
+    remote_dtype = pixel_format_to_numpy_type(image_response.shot.image.pixel_format)
     if image_response.shot.image.pixel_format in (image_pb2.Image.PIXEL_FORMAT_DEPTH_U16,
                                                   image_pb2.Image.PIXEL_FORMAT_GREYSCALE_U16):
-        dtype = np.uint16
+        local_dtype = np.uint16
         max_val = np.iinfo(np.uint16).max
     else:
-        dtype = np.uint8
+        local_dtype = np.uint8
         max_val = np.iinfo(np.uint8).max
 
     num_channels = 1
@@ -259,11 +260,11 @@ def write_pgm_or_ppm(image_response, filename="", filepath=".", include_pixel_fo
               image_pb2.Image.PixelFormat.Name(image_response.shot.image.pixel_format))
         return
 
-    img = np.frombuffer(image_response.shot.image.data, dtype=dtype)
+    img = np.frombuffer(image_response.shot.image.data, dtype=remote_dtype)
     height = image_response.shot.image.rows
     width = image_response.shot.image.cols
     try:
-        img = img.reshape((height, width, num_channels))
+        img = img.astype(local_dtype).reshape((height, width, num_channels))
     except ValueError as err:
         print(
             "Cannot convert raw image into expected shape (rows %d, cols %d, color channels %d)." %

bosdyn/client/image_service_helpers.py

@@ -14,17 +14,16 @@ from abc import ABC, abstractmethod
 
 import numpy as np
 
-from bosdyn.api import (header_pb2, image_pb2, image_service_pb2, image_service_pb2_grpc,
-                        service_customization_pb2, service_fault_pb2)
+from bosdyn.api import (image_pb2, image_service_pb2_grpc, service_customization_pb2,
+                        service_fault_pb2)
 from bosdyn.client.data_buffer import DataBufferClient
 from bosdyn.client.exceptions import RpcError
 from bosdyn.client.fault import (FaultClient, ServiceFaultAlreadyExistsError,
                                  ServiceFaultDoesNotExistError)
-from bosdyn.client.image import UnsupportedPixelFormatRequestedError
 from bosdyn.client.server_util import ResponseContext, populate_response_header
-from bosdyn.client.service_customization_helpers import create_value_validator, validate_dict_spec
+from bosdyn.client.service_customization_helpers import create_value_validator
 from bosdyn.client.util import setup_logging
-from bosdyn.util import sec_to_nsec, seconds_to_duration
+from bosdyn.util import now_sec, seconds_to_duration
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -577,13 +576,13 @@ class ImageCaptureThread():
         """Main loop for the image capture thread, which requests and saves images."""
         while not self.stop_capturing_event.is_set():
             # Get the image by calling the blocking capture function.
-            start_time = time.time()
+            start_time = now_sec()
             capture, capture_time = self.capture_function()
             self.set_last_captured_image(capture, capture_time)
 
             # Wait for the total capture period (where the wait time is adjusted based on how
             # long the capture took).
-            wait_time = self.capture_period_secs - (time.time() - start_time)
+            wait_time = self.capture_period_secs - (now_sec() - start_time)
             if self.stop_capturing_event.wait(wait_time):
                 # If stop_capturing_event is set, then break from the capture loop now.
                 break

bosdyn/client/ir_enable_disable.py

@@ -43,4 +43,4 @@ class IREnableDisableServiceClient(BaseClient):
             request = ir_enable_disable_pb2.IREnableDisableRequest.REQUEST_OFF
         return self.call_async(self._stub.IREnableDisable,
                                ir_enable_disable_pb2.IREnableDisableRequest(request=request),
-                               error_from_response=common_header_errors, **kwargs)
+                               error_from_response=common_header_errors, **kwargs)

bosdyn/client/keepalive.py

@@ -16,11 +16,13 @@ from typing import Callable, List, Union
 
 import bosdyn.client.lease
 import bosdyn.util
+from bosdyn.api import lease_pb2
 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
+from bosdyn.util import now_sec
 
 
 class KeepaliveResponseError(ResponseError):
@@ -290,7 +292,7 @@ class PolicyKeepalive():
         # 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()
+            exec_start = now_sec()
             action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
 
             try:
@@ -309,7 +311,7 @@ class PolicyKeepalive():
                 else:
                     raise
             # How long did the RPC and processing of said RPC take?
-            exec_seconds = time.time() - exec_start
+            exec_seconds = now_sec() - exec_start
 
             if action == ErrorCallbackResult.ABORT:
                 self.logger.warning('Callback directed the keepalive thread to exit.')

bosdyn/client/lease.py

@@ -19,6 +19,7 @@ from bosdyn.api.lease_pb2 import (LeaseUseResult, ListLeasesRequest, RetainLease
                                   ReturnLeaseRequest, ReturnLeaseResponse, TakeLeaseRequest,
                                   TakeLeaseResponse)
 from bosdyn.api.lease_service_pb2_grpc import LeaseServiceStub
+from bosdyn.util import now_sec
 
 from . import common
 from .exceptions import Error as BaseError
@@ -987,7 +988,7 @@ class LeaseKeepAlive(object):
         while True:
             # Include the time it takes to execute keep_running, in case it takes a significant
             # portion of our check in period.
-            exec_start = time.time()
+            exec_start = now_sec()
 
             # Stop doing retention if this is not meant to keep running.
             if not self._keep_running():
@@ -1008,7 +1009,7 @@ class LeaseKeepAlive(object):
                 self._ok()
 
             # How long did the RPC and processing of said RPC take?
-            exec_seconds = time.time() - exec_start
+            exec_seconds = now_sec() - 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!

bosdyn/client/lease_validator.py

@@ -11,7 +11,6 @@ import logging
 import threading
 
 from bosdyn.api import lease_pb2
-from bosdyn.client.exceptions import Error
 from bosdyn.client.lease import Lease, LeaseClient
 from bosdyn.client.lease_resource_hierarchy import ResourceHierarchy
 

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