bosdyn-client 4.0.2__py3-none-any.whl → 4.1.0__py3-none-any.whl

bosdyn/client/data_acquisition_store.py

@@ -7,21 +7,24 @@
 """Client implementation for data acquisition store service.
 """
 
-import collections
-import functools
-import json
+from os import fstat
+from pathlib import Path
 
 from google.protobuf import json_format
 
 from bosdyn.api import data_acquisition_store_pb2 as data_acquisition_store
 from bosdyn.api import data_acquisition_store_service_pb2_grpc as data_acquisition_store_service
-from bosdyn.api import image_pb2
-from bosdyn.client import data_chunk
+from bosdyn.api import data_chunk_pb2 as data_chunk
+from bosdyn.api import header_pb2, image_pb2
+from bosdyn.client.channel import DEFAULT_HEADER_BUFFER_LENGTH, DEFAULT_MAX_MESSAGE_LENGTH
 from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,
                                   handle_common_header_errors, handle_unset_status_error)
+from bosdyn.client.data_chunk import split_serialized
 from bosdyn.client.exceptions import Error, ResponseError
 from bosdyn.util import now_timestamp
 
+DEFAULT_CHUNK_SIZE_BYTES = int(DEFAULT_MAX_MESSAGE_LENGTH - DEFAULT_HEADER_BUFFER_LENGTH)
+
 
 class DataAcquisitionStoreClient(BaseClient):
     """A client for triggering data acquisition store methods."""
@@ -255,11 +258,64 @@ class DataAcquisitionStoreClient(BaseClient):
                                error_from_response=common_header_errors, copy_request=False,
                                **kwargs)
 
+    def store_data_as_chunks(self, data, data_id, file_extension=None, **kwargs):
+        """Store data using streaming, supports storing of large data that is too large for a single store_data rpc. Note: using this rpc means that the data must be loaded into memory.
+
+        Args:
+            data (bytes) : Arbitrary data to store.
+            data_id (bosdyn.api.DataIdentifier) : Data identifier to use for storing this data.
+            file_extension (string) : File extension to use for writing the data to a file.
+
+        Returns:
+             StoreDataResponse final successful response or first failed response.
+        """
+        return self.call(self._stub.StoreDataStream,
+                         _iterate_data_chunks(data, data_id, file_extension),
+                         error_from_response=common_header_errors, value_from_response=None,
+                         copy_request=False, **kwargs)
+
+    def store_data_as_chunks_async(self, data, data_id, file_extension=None, **kwargs):
+        """Async version of the store_data_as_chunks() RPC."""
+        return self.call_async_streaming(
+            self._stub.StoreDataStream, _iterate_data_chunks(data, data_id, file_extension),
+            error_from_response=common_header_errors, value_from_response=None,
+            assemble_type=data_acquisition_store.StoreStreamResponse, copy_request=False, **kwargs)
+
+    def store_file(self, file_path, data_id, file_extension=None, **kwargs):
+        """Store file using file path, supports storing of large files that are too large for a single store_data rpc.
+
+        Args:
+            file_path (string) : File path to arbitrary data to store.
+            data_id (bosdyn.api.DataIdentifier) : Data identifier to use for storing this data.
+            file_extension (string) : File extension to use for writing the data to a file.
+
+        Returns:
+             StoreDataResponse final successful response or first failed response.
+        """
+
+        file_abs = Path(file_path).absolute()
+        file = open(file_abs, "rb")
+        return self.call(self._stub.StoreDataStream,
+                         _iterate_store_file(file, data_id, file_extension=file_extension),
+                         error_from_response=common_header_errors, value_from_response=None,
+                         copy_request=False, **kwargs)
+
+    def store_file_async(self, file_path, data_id, file_extension=None, **kwargs):
+        """Async version of the store_file() RPC."""
+
+        file_abs = Path(file_path).absolute()
+        file = open(file_abs, "rb")
+        return self.call_async_streaming(
+            self._stub.StoreDataStream,
+            _iterate_store_file(file, data_id, file_extension=file_extension),
+            error_from_response=common_header_errors, value_from_response=None,
+            assemble_type=data_acquisition_store.StoreStreamResponse, copy_request=False, **kwargs)
+
     def query_stored_captures(self, query=None, **kwargs):
         """Query stored captures from the robot.
 
         Args:
-            query (bosdyn.api.DataQueryParams) : Query parameters.
+            query (bosdyn.api.QueryParameters) : Query parameters.
         Raises:
             RpcError: Problem communicating with the robot.
         """
@@ -270,6 +326,15 @@ class DataAcquisitionStoreClient(BaseClient):
                          assemble_type=data_acquisition_store.QueryStoredCapturesResponse,
                          copy_request=False, **kwargs)
 
+    def query_stored_captures_async(self, query=None, **kwargs):
+        """Async version of the query_stored_captures() RPC."""
+        request = data_acquisition_store.QueryStoredCapturesRequest(query=query)
+        self._apply_request_processors(request, copy_request=False)
+        return self.call_async_streaming(
+            self._stub.QueryStoredCaptures, request, error_from_response=common_header_errors,
+            assemble_type=data_acquisition_store.QueryStoredCapturesResponse, copy_request=False,
+            **kwargs)
+
     def query_max_capture_id(self, **kwargs):
         """Query max capture id from the robot.
         Returns:
@@ -284,13 +349,53 @@ class DataAcquisitionStoreClient(BaseClient):
 
     def query_max_capture_id_async(self, **kwargs):
         """Async version of the query_max_capture_id() RPC."""
-        request = data_acquisition_store.QueryMaxCaptureIdRequest(query=query)
+        request = data_acquisition_store.QueryMaxCaptureIdRequest()
         return self.call_async(self._stub.QueryMaxCaptureId, request,
                                value_from_response=_get_max_capture_id,
                                error_from_response=common_header_errors, copy_request=False,
                                **kwargs)
 
 
+def _iterate_store_file(file, data_id, file_extension=None):
+    """Iterator over file data and create multiple StoreStreamRequest
+
+        Args:
+            file (BufferedReader) : Reader to the file for arbitrary data to store.
+            data_id (bosdyn.api.DataIdentifier) : Data identifier to use for storing this data.
+            file_extension (string) : File extension to use for writing the data to a file.
+        Returns:
+            StoreStreamRequests iterates over these requests.
+        """
+    total_size = fstat(file.fileno()).st_size
+    while True:
+        chunk = file.read(DEFAULT_CHUNK_SIZE_BYTES)
+        if not chunk:
+            # No more data
+            break
+        data = data_chunk.DataChunk(data=chunk, total_size=total_size)
+        request = data_acquisition_store.StoreStreamRequest(chunk=data, data_id=data_id,
+                                                            file_extension=file_extension)
+        yield request
+
+
+def _iterate_data_chunks(data, data_id, file_extension=None):
+    """Iterator over data and create multiple StoreDataRequest
+
+        Args:
+            data (bytes) : Arbitrary data to store.
+            data_id (bosdyn.api.DataIdentifier) : Data identifier to use for storing this data.
+            file_extension (string) : File extension to use for writing the data to a file.
+        Returns:
+            StoreDataRequests iterates over these requests.
+        """
+    total_size = len(data)
+    for chunk in split_serialized(data, DEFAULT_CHUNK_SIZE_BYTES):
+        chunk_data = data_chunk.DataChunk(data=chunk, total_size=total_size)
+        request = data_acquisition_store.StoreStreamRequest(chunk=chunk_data, data_id=data_id,
+                                                            file_extension=file_extension)
+        yield request
+
+
 def _get_action_ids(response):
     return response.action_ids
 

bosdyn/client/frame_helpers.py

@@ -14,6 +14,7 @@ BODY_FRAME_NAME = "body"
 # string identifier.
 GRAV_ALIGNED_BODY_FRAME_NAME = "flat_body"
 ODOM_FRAME_NAME = "odom"
+SEED_FRAME_NAME = "seed"
 GROUND_PLANE_FRAME_NAME = "gpe"
 HAND_FRAME_NAME = "hand"
 UNKNOWN_FRAME_NAME = "unknown"
@@ -33,6 +34,7 @@ FOOT_FRAME_NAMES = [
     HIND_RIGHT_FOOT_FRAME_NAME
 ]
 WR1_FRAME_NAME = "arm0.link_wr1"
+WAYPOINT_FRAME_NAME = "waypoint"
 
 
 class Error(Exception):

bosdyn/client/gps/NMEAParser.py

@@ -92,13 +92,14 @@ class NMEAParser(object):
                 data_point.timestamp_gps.FromDatetime(gps_timestamp_no_tz)
                 has_timestamp = True
 
-            # Populate client and robot timestamps.
+            # Populate client and robot timestamps. If we are not using TimeSync, the robot
+            # timestamp will be the same as the client timestamp.
             data_point.timestamp_client.CopyFrom(seconds_to_timestamp(client_timestamp))
             if time_converter is not None:
                 data_point.timestamp_robot.CopyFrom(
                     time_converter.robot_timestamp_from_local_secs(client_timestamp))
             else:
-                data_point.timestamp_robot.CopyFrom(now_timestamp())
+                data_point.timestamp_robot.CopyFrom(data_point.timestamp_client)
 
 
         if not has_timestamp and not has_warned_no_zda:
@@ -110,8 +111,8 @@ class NMEAParser(object):
 
     def parse(self, new_data: str, time_converter: RobotTimeConverter,
               check: bool = True) -> List[GpsDataPoint]:
-        self.data = self.data + new_data
         timestamp = time.time()  # Client timestamp when received.
+        self.data = self.data + new_data
 
         if len(self.data) == 0:
             return []  # Protection because empty_string.splitlines() returns empty array

bosdyn/client/gps/aggregator_client.py

@@ -5,7 +5,6 @@
 # Development Kit License (20191101-BDSDK-SL).
 
 """For clients to use the Gps Aggregator service."""
-import collections
 
 from bosdyn.api.gps import aggregator_pb2, aggregator_service_pb2_grpc, gps_pb2
 from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,

bosdyn/client/gps/gps_listener.py

@@ -6,7 +6,6 @@
 
 """Reads GPS data from a tcp/udp stream, and sends to aggregator service."""
 
-import logging
 import signal
 import socket
 import time
@@ -40,7 +39,7 @@ class NMEAStreamReader(object):
         try:
             raw_data = self.stream.readline()
             # If the rawdata is a bytes or bytearray object, decode it into a string.
-            if type(raw_data) is not str:
+            if not isinstance(raw_data, str):
                 raw_data = str(raw_data, "utf-8")
         except UnicodeDecodeError:
             # Throttle the logs.
@@ -159,4 +158,3 @@ class GpsListener:
 
         except KeyboardInterrupt:
             print()  # Get past the ^C in the console output
-            pass

bosdyn/client/graph_nav.py

@@ -17,8 +17,9 @@ from bosdyn.api.graph_nav import (graph_nav_pb2, graph_nav_service_pb2, graph_na
                                   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_unset_status_error)
-from bosdyn.client.exceptions import Error, InvalidRequestError, ResponseError
+                                  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.lease import add_lease_wallet_processors
 
 
@@ -31,6 +32,7 @@ class GraphNavClient(BaseClient):
         super(GraphNavClient, self).__init__(graph_nav_service_pb2_grpc.GraphNavServiceStub)
         self._timesync_endpoint = None
         self._data_chunk_size = 1024 * 1024  # bytes = 1 MB
+        self._use_streaming_graph_upload = True
 
     def update_from(self, other):
         super(GraphNavClient, self).update_from(other)
@@ -236,18 +238,31 @@ class GraphNavClient(BaseClient):
         return self.call(self._stub.NavigateRoute, request,
                          error_from_response=_navigate_route_error, copy_request=False, **kwargs)
 
-    def navigate_route_full_async(self, route, cmd_duration, route_follow_params=None,
-                                  travel_params=None, leases=None, timesync_endpoint=None,
-                                  command_id=None, destination_waypoint_tform_body_goal=None,
-                                  **kwargs):
+    def navigate_route_full_async(
+            self,
+            route,
+            cmd_duration,
+            route_follow_params=None,
+            travel_params=None,
+            leases=None,
+            timesync_endpoint=None,
+            command_id=None,
+            destination_waypoint_tform_body_goal=None,
+            **kwargs):
         """Async version of navigate_route_full()."""
         used_endpoint = timesync_endpoint or self._timesync_endpoint
         if not used_endpoint:
             raise GraphNavServiceResponseError(response=None, error_message='No timesync endpoint!')
-        request = self._build_navigate_route_request(route, route_follow_params, travel_params,
-                                                     cmd_duration, leases, used_endpoint,
-                                                     command_id,
-                                                     destination_waypoint_tform_body_goal)
+        request = self._build_navigate_route_request(
+            route,
+            route_follow_params,
+            travel_params,
+            cmd_duration,
+            leases,
+            used_endpoint,
+            command_id,
+            destination_waypoint_tform_body_goal,
+        )
         return self.call_async(self._stub.NavigateRoute, request,
                                error_from_response=_navigate_route_error, copy_request=False,
                                **kwargs)
@@ -457,9 +472,30 @@ class GraphNavClient(BaseClient):
             The response, which includes waypoint and edge id's sorted by whether it was cached.
         Raises:
             RpcError: Problem communicating with the robot.
+            UploadGraphError: Indicates a problem with the map provided.
+            IncompatibleSensorsError: The map was recorded with different sensors than the robot.
+            AreaCallbackError: The map includes area callback services not present on the robot.
             LeaseUseError: Error using provided lease.
+            LicenseError: The robot's license is not valid.
         """
         request = self._build_upload_graph_request(lease, graph, generate_new_anchoring)
+        # 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.
+            self._apply_request_processors(request, copy_request=False)
+            serialized = request.SerializeToString()
+            try:
+                return self.call(
+                    self._stub.UploadGraphStreaming,
+                    GraphNavClient._data_chunk_iterator_upload_graph(serialized,
+                                                                     self._data_chunk_size),
+                    value_from_response=_get_response, error_from_response=_upload_graph_error,
+                    **kwargs)
+            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)
+                # 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)
 
@@ -520,6 +556,17 @@ class GraphNavClient(BaseClient):
             RpcError: Problem communicating with the robot
         """
         request = self._build_download_graph_request()
+        # Use streaming to download the graph, if applicable.
+        if self._use_streaming_graph_upload:
+            try:
+                resp = self.call(self._stub.DownloadGraphStreaming, request,
+                                 value_from_response=_get_streamed_download_graph,
+                                 error_from_response=_download_graph_stream_errors,
+                                 copy_request=False, **kwargs)
+                return resp
+            except UnimplementedError:
+                print('DownloadGraphStreaming unimplemented. Old robot release?')
+                # Continue to regular DownloadGraph.
         return self.call(self._stub.DownloadGraph, request, value_from_response=_get_graph,
                          error_from_response=common_header_errors, copy_request=False, **kwargs)
 
@@ -644,9 +691,16 @@ class GraphNavClient(BaseClient):
             request_gps_state=request_gps_state)
 
     @staticmethod
-    def _build_navigate_route_request(route, route_follow_params, travel_params, end_time_secs,
-                                      leases, timesync_endpoint, command_id,
-                                      destination_waypoint_tform_body_goal):
+    def _build_navigate_route_request(
+        route,
+        route_follow_params,
+        travel_params,
+        end_time_secs,
+        leases,
+        timesync_endpoint,
+        command_id,
+        destination_waypoint_tform_body_goal,
+    ):
         converter = timesync_endpoint.get_robot_time_converter()
         request = graph_nav_pb2.NavigateRouteRequest(
             route=route, route_follow_params=route_follow_params,
@@ -719,6 +773,22 @@ class GraphNavClient(BaseClient):
         return graph_nav_pb2.UploadGraphRequest(lease=lease, graph=graph,
                                                 generate_new_anchoring=generate_new_anchoring)
 
+    @staticmethod
+    def _data_chunk_iterator_upload_graph(serialized_upload_graph, data_chunk_byte_size):
+        """Converts a serialized UploadGraphRequest into a series of UploadGraphStreamingRequests."""
+        total_bytes_size = len(serialized_upload_graph)
+        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_upload_graph[start_index:total_bytes_size]
+            else:
+                chunk.data = serialized_upload_graph[start_index:end_index]
+            req = graph_nav_pb2.UploadGraphStreamingRequest(chunk=chunk)
+            yield req
+
     @staticmethod
     def _data_chunk_iterator_upload_waypoint_snapshot(serialized_waypoint_snapshot, lease,
                                                       data_chunk_byte_size):
@@ -995,36 +1065,26 @@ def _get_graph(response):
     return response.graph
 
 
+def _get_streamed_data(response, data_type):
+    """Given a list of streamed responses, return an instance of the given data type that is parsed from those responses."""
+    data = bytes()
+    for resp in response:
+        data += resp.chunk.data
+    proto_instance = data_type()
+    proto_instance.ParseFromString(data)
+    return proto_instance
+
+
+
+
 def _get_streamed_waypoint_snapshot(response):
     """Reads a streamed response to recreate a waypoint snapshot."""
-    data = ''
-    num_chunks = 0
-    for resp in response:
-        if num_chunks == 0:
-            data = resp.chunk.data
-        else:
-            data += resp.chunk.data
-        num_chunks += 1
-    waypoint_snapshot = map_pb2.WaypointSnapshot()
-    if (num_chunks > 0):
-        waypoint_snapshot.ParseFromString(data)
-    return waypoint_snapshot
+    return _get_streamed_data(response, map_pb2.WaypointSnapshot)
 
 
 def _get_streamed_edge_snapshot(response):
     """Reads a streamed response to recreate an edge snapshot."""
-    data = ''
-    num_chunks = 0
-    for resp in response:
-        if num_chunks == 0:
-            data = resp.chunk.data
-        else:
-            data += resp.chunk.data
-        num_chunks += 1
-    edge_snapshot = map_pb2.EdgeSnapshot()
-    if (num_chunks > 0):
-        edge_snapshot.ParseFromString(data)
-    return edge_snapshot
+    return _get_streamed_data(response, map_pb2.EdgeSnapshot)
 
 
 _UPLOAD_GRAPH_STATUS_TO_ERROR = collections.defaultdict(lambda: (ResponseError, None))
@@ -1043,6 +1103,7 @@ _UPLOAD_GRAPH_STATUS_TO_ERROR.update({
 
 @handle_common_header_errors
 @handle_lease_use_result_errors
+@handle_license_errors_if_present
 @handle_unset_status_error(unset='STATUS_UNKNOWN')
 def _upload_graph_error(response):
     """Return a custom exception based on upload graph response, None if no error."""

bosdyn/client/image.py

@@ -170,7 +170,7 @@ class ImageClient(BaseClient):
 
 
 def build_image_request(image_source_name, quality_percent=75, image_format=None, pixel_format=None,
-                        resize_ratio=None):
+                        resize_ratio=None, fallback_formats=None):
     """Helper function which builds an ImageRequest from an image source name.
 
     By default the robot will choose an appropriate format when no image format
@@ -184,13 +184,16 @@ def build_image_request(image_source_name, quality_percent=75, image_format=None
                                                data, such as JPEG, RAW, or RLE.
         pixel_format (image_pb2.Image.PixelFormat) The pixel format of the image.
         resize_ratio (double): Resize ratio for image dimensions.
+        fallback_formats (image_pb2.Image.PixelFormat) Fallback pixel formats to use
+        if the pixel_format is invalid.
 
     Returns:
         The ImageRequest protobuf message for the given parameters.
     """
     return image_pb2.ImageRequest(image_source_name=image_source_name,
                                   quality_percent=quality_percent, image_format=image_format,
-                                  pixel_format=pixel_format, resize_ratio=resize_ratio)
+                                  pixel_format=pixel_format, fallback_formats=fallback_formats,
+                                  resize_ratio=resize_ratio)
 
 
 def _list_image_sources_value(response):

bosdyn/client/image_service_helpers.py

@@ -76,7 +76,6 @@ class CameraInterface(ABC):
             A tuple with image data (in any format), and the capture timestamp in seconds (float) in the
             service computer's clock.
         """
-        pass
 
     @abstractmethod
     def image_decode(self, image_data, image_proto, image_req):
@@ -92,7 +91,6 @@ class CameraInterface(ABC):
             pixel format, image format, and potentially the transform snapshot fields within the image_proto
             protobuf message.
         """
-        pass
 
 
 class VisualImageSource():
@@ -575,7 +573,7 @@ class ImageCaptureThread():
 
     def _do_image_capture(self):
         """Main loop for the image capture thread, which requests and saves images."""
-        while not self.stop_capturing_event.isSet():
+        while not self.stop_capturing_event.is_set():
             # Get the image by calling the blocking capture function.
             start_time = time.time()
             capture, capture_time = self.capture_function()

bosdyn/client/map_processing.py

@@ -6,9 +6,6 @@
 
 """For clients of the graph_nav map processing service."""
 
-import collections
-from enum import Enum
-
 from bosdyn.api.graph_nav import map_pb2, map_processing_pb2, map_processing_service_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,

bosdyn/client/power.py

@@ -15,8 +15,9 @@ 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.client.common import (BaseClient, error_factory, handle_common_header_errors,
-                                  handle_lease_use_result_errors, handle_unset_status_error)
+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)
 
@@ -190,19 +191,10 @@ def _handle_license_errors(func):
 
 def _common_license_errors(response):
     """Return an exception based on license status. None if no error."""
-
-    license_status = None
     if response.status != power_pb2.STATUS_LICENSE_ERROR:
         return None
-    if hasattr(response, 'license_status'):
-        license_status = response.license_status
-    else:
-        # This means you're using the wrong error handler.
-        return InternalServerError(response, 'No LicenseInfo.Status field found!')
-
-    if license_status != license_pb2.LicenseInfo.STATUS_VALID:
-        return LicenseError(response)
-    return None
+
+    return common_license_errors(response)
 
 
 @handle_common_header_errors

bosdyn/client/recording.py

@@ -13,7 +13,7 @@ from bosdyn.api.graph_nav import map_pb2, nav_pb2, recording_pb2, recording_serv
 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_unset_status_error)
+                                  handle_license_errors_if_present, handle_unset_status_error)
 from bosdyn.client.exceptions import ResponseError
 
 
@@ -275,14 +275,13 @@ class GraphNavRecordingServiceClient(BaseClient):
     @staticmethod
     def make_edge_environment(
             vel_limit=None, direction_constraint=map_pb2.Edge.Annotations.DIRECTION_CONSTRAINT_NONE,
-            require_alignment=False, flat_ground=False, ground_mu_hint=.8, grated_floor=False):
+            require_alignment=False, ground_mu_hint=.8, grated_floor=False):
         """Create an edge environment.
 
         Args:
             vel_limit: A SE2VelocityLimit to use while traversing the edge. Note this is not a target speed, just a max/min.
             direction_constraint: A direction constraints on the robot's orientation when traversing the edge.
             require_alignment: Boolean where if true, the robot must be aligned with the edge in yaw before traversing it.
-            flat_ground: Boolean where if true, the edge crosses flat ground and the robot shouldn't try to climb over obstacles.
             ground_mu_hint: Terrain coefficient of friction user hint. Suggested values lie between [.4, .8].
             grated_floor: Boolean where if true, the edge crosses over grated metal.
         Returns:
@@ -290,7 +289,6 @@ class GraphNavRecordingServiceClient(BaseClient):
         """
         edge_env = map_pb2.Edge.Annotations()
         edge_env.require_alignment.value.CopyFrom(require_alignment)
-        edge_env.flat_ground.value.CopyFrom(flat_ground)
         edge_env.grated_floor.value.CopyFrom(grated_floor)
         if (ground_mu_hint > 0):
             edge_env.ground_mu_hint.value.CopyFrom(ground_mu_hint)
@@ -438,6 +436,7 @@ _START_RECORDING_STATUS_TO_ERROR.update({
 
 @handle_common_header_errors
 # @handle_lease_use_result_errors
+@handle_license_errors_if_present
 @handle_unset_status_error(unset='STATUS_UNKNOWN')
 def _start_recording_error(response):
     """Return a custom exception based on start recording response, None if no error."""
@@ -482,6 +481,7 @@ _CREATE_WAYPOINT_STATUS_TO_ERROR.update({
 
 @handle_common_header_errors
 # @handle_lease_use_result_errors
+@handle_license_errors_if_present
 @handle_unset_status_error(unset='STATUS_UNKNOWN')
 def _create_waypoint_error(response):
     """Return a custom exception based on create waypoint response, None if no error."""

bosdyn/client/robot.py

@@ -129,6 +129,7 @@ class Robot(object):
         self.cert = None
         self.lease_wallet = LeaseWallet()
         self._time_sync_thread = None
+        self.executor = None
 
         # Set default max message length for sending and receiving. These values are used when
         # creating channels.
@@ -198,6 +199,7 @@ class Robot(object):
         self.max_receive_message_length = other.max_receive_message_length
         self.client_name = other.client_name
         self.lease_wallet.set_client_name(self.client_name)
+        self.executor = other.executor
 
     def ensure_client(self, service_name, channel=None, options=[], service_endpoint=None):
         """Ensure a Client for a given service.
@@ -247,7 +249,7 @@ class Robot(object):
         for channel_from_auth in self.channels_by_authority.values():
             channel_from_auth.close()
 
-    def get_cached_robot_id(self):
+    def get_cached_robot_id(self, timeout=None):
         """Return the RobotId proto for this robot, querying it from the robot if not yet cached.
 
         Raises:
@@ -255,10 +257,10 @@ class Robot(object):
         """
         if not self._robot_id:
             robot_id_client = self.ensure_client('robot-id')
-            self._robot_id = robot_id_client.get_id()
+            self._robot_id = robot_id_client.get_id(timeout=timeout)
         return self._robot_id
 
-    def get_cached_hardware_hardware_configuration(self):
+    def get_cached_hardware_hardware_configuration(self, timeout=None):
         """Return the HardwareConfiguration proto for this robot, querying it from the robot if not
         yet cached.
 
@@ -267,7 +269,7 @@ class Robot(object):
         """
         if not self._hardware_config:
             client = self.ensure_client(RobotStateClient.default_service_name)
-            self._hardware_config = client.get_robot_hardware_configuration()
+            self._hardware_config = client.get_robot_hardware_configuration(timeout=timeout)
         return self._hardware_config
 
 
@@ -411,7 +413,6 @@ class Robot(object):
                     self.logger.warning(
                         'Payload is not authorized. Authentication will block until an'
                         ' operator authorizes the payload in the Admin Console.')
-                pass
             time.sleep(0.1)
         self.update_user_token(user_token)