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

bosdyn/client/image_service_helpers.py

@@ -4,6 +4,7 @@
 # is subject to the terms and conditions of the Boston Dynamics Software
 # Development Kit License (20191101-BDSDK-SL).
 
+import contextlib
 import inspect
 import logging
 import sys
@@ -15,11 +16,12 @@ 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.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 populate_response_header
+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.util import setup_logging
 from bosdyn.util import sec_to_nsec, seconds_to_duration
@@ -430,7 +432,7 @@ class VisualImageSource():
             exposure (float | function): The exposure time for an image in seconds. This can be a fixed
                               value or a function which returns the exposure time as a float.
             request_custom_params (service_customization_pb2.DictParam): Custom Params associated with the image
-                            request. Should not be 'None', but left as an option to accomodate old callers
+                            request. Should not be 'None', but left as an option to accommodate old callers
         Returns:
             An instance of the protobuf CaptureParameters message.
         """
@@ -562,7 +564,7 @@ class ImageCaptureThread():
         """Update the capture function to use custom_params and capture_func_kwargs if it can"""
 
         # capture_func is likely provided through create_capture_thread, which already does handling for pre-3.3 blocking_capture
-        # Still, check for the custom_params argument to ensure we accomodate pre-3.3 direct implementations of ImageCaptureThreads
+        # Still, check for the custom_params argument to ensure we accommodate pre-3.3 direct implementations of ImageCaptureThreads
         if "custom_params" in inspect.signature(capture_func).parameters.keys():
             #If using a blocking capture function that takes in custom params or kwargs, one should supply those
             def output_capture_function():
@@ -607,10 +609,14 @@ class CameraBaseImageServicer(image_service_pb2_grpc.ImageServiceServicer):
             the image service will call an image sources' blocking_capture_function during the GetImage request.
         background_capture_params (service_customization_pb2.DictParam): If use_background_capture_thread is true,
             custom image source parameters used for all of the background captures. Otherwise ignored
+        log_images (bool): if true, include image request/response messages in robot logs.  This is turned off
+            by default.
+
     """
 
     def __init__(self, bosdyn_sdk_robot, service_name, image_sources, logger=None,
-                 use_background_capture_thread=True, background_capture_params=None):
+                 use_background_capture_thread=True, background_capture_params=None,
+                 log_images=False):
         super(CameraBaseImageServicer, self).__init__()
         if logger is None:
             # Set up the logger to remove duplicated messages and use a specific logging format.
@@ -627,6 +633,13 @@ class CameraBaseImageServicer(image_service_pb2_grpc.ImageServiceServicer):
         # Fault client to report service faults
         self.fault_client = self.bosdyn_sdk_robot.ensure_client(FaultClient.default_service_name)
 
+        if log_images:
+            # Data buffer client for logging messages
+            self.data_buffer_client = self.bosdyn_sdk_robot.ensure_client(
+                DataBufferClient.default_service_name)
+        else:
+            self.data_buffer_client = None
+
         # Get a timesync endpoint from the robot instance such that the image timestamps can be
         # reported in the robot's time.
         self.bosdyn_sdk_robot.time_sync.wait_for_sync()
@@ -681,74 +694,81 @@ class CameraBaseImageServicer(image_service_pb2_grpc.ImageServiceServicer):
             specified in the request.
         """
         response = image_pb2.GetImageResponse()
-        for img_req in request.image_requests:
-            img_resp = response.image_responses.add()
-            src_name = img_req.image_source_name
-            if src_name not in self.image_sources_mapped:
-                # The requested camera source does not match the name of the Ricoh Theta camera, so it cannot
-                # be completed and will have a failure status in the response message.
-                img_resp.status = image_pb2.ImageResponse.STATUS_UNKNOWN_CAMERA
-                self.logger.warning("Camera source '%s' is unknown.", src_name)
-                continue
-
-            if img_req.resize_ratio < 0 or img_req.resize_ratio > 1:
-                img_resp.status = image_pb2.ImageResponse.STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED
-                self.logger.warning("Resize ratio %f is unsupported.", img_req.resize_ratio)
-                continue
-
-            if img_req.HasField("custom_params"):
-                value_validation_error = self.image_sources_mapped[src_name].value_validator(
-                    img_req.custom_params)
-                if value_validation_error:
-                    img_resp.status = image_pb2.ImageResponse.STATUS_CUSTOM_PARAMS_ERROR
-                    img_resp.custom_param_error.CopyFrom(value_validation_error)
+        if self.data_buffer_client is not None:
+            response_context = ResponseContext(response, request, self.data_buffer_client)
+        else:
+            response_context = contextlib.nullcontext()
+        with response_context:
+            for img_req in request.image_requests:
+                img_resp = response.image_responses.add()
+                src_name = img_req.image_source_name
+                if src_name not in self.image_sources_mapped:
+                    # The requested camera source does not match the name of the Ricoh Theta camera, so it cannot
+                    # be completed and will have a failure status in the response message.
+                    img_resp.status = image_pb2.ImageResponse.STATUS_UNKNOWN_CAMERA
+                    self.logger.warning("Camera source '%s' is unknown.", src_name)
+                    continue
+
+                if img_req.resize_ratio < 0 or img_req.resize_ratio > 1:
+                    img_resp.status = image_pb2.ImageResponse.STATUS_UNSUPPORTED_RESIZE_RATIO_REQUESTED
+                    self.logger.warning("Resize ratio %f is unsupported.", img_req.resize_ratio)
                     continue
 
-            # Set the image source information in the response.
-            img_resp.source.CopyFrom(self.image_sources_mapped[src_name].image_source_proto)
+                if img_req.HasField("custom_params"):
+                    value_validation_error = self.image_sources_mapped[src_name].value_validator(
+                        img_req.custom_params)
+                    if value_validation_error:
+                        img_resp.status = image_pb2.ImageResponse.STATUS_CUSTOM_PARAMS_ERROR
+                        img_resp.custom_param_error.CopyFrom(value_validation_error)
+                        continue
+
+                # Set the image source information in the response.
+                img_resp.source.CopyFrom(self.image_sources_mapped[src_name].image_source_proto)
+
+                # Set the image capture parameters in the response.
+                img_resp.shot.capture_params.CopyFrom(
+                    self.image_sources_mapped[src_name].get_image_capture_params(
+                        img_req.custom_params))
+
+                if img_req.HasField("custom_params"):
+                    #If future keyword arguments are added here, they'll need to be added to this call
+                    #get_image_and_timestamp already calls a 'sanitized' capture function that handles pre-3.3 blocking_captures
+                    captured_image, img_time_seconds = self.image_sources_mapped[
+                        src_name].get_image_and_timestamp(custom_params=img_req.custom_params)
+                else:
+                    #get_image_and_timestamp() can accommodate pre-3.3 blocking_capture calls if no custom params are supplied
+                    captured_image, img_time_seconds = self.image_sources_mapped[
+                        src_name].get_image_and_timestamp()
+
+                if captured_image is None or img_time_seconds is None:
+                    img_resp.status = image_pb2.ImageResponse.STATUS_IMAGE_DATA_ERROR
+                    error_message = "Failed to capture an image from %s on the server." % src_name
+                    response.header.error.message = error_message
+                    self.logger.warning(error_message)
+                    continue
 
-            # Set the image capture parameters in the response.
-            img_resp.shot.capture_params.CopyFrom(
-                self.image_sources_mapped[src_name].get_image_capture_params(img_req.custom_params))
+                # Convert the image capture time from the local clock time into the robot's time. Then set it as
+                # the acquisition timestamp for the image data.
+                img_resp.shot.acquisition_time.CopyFrom(
+                    self.bosdyn_sdk_robot.time_sync.robot_timestamp_from_local_secs(
+                        img_time_seconds))
 
-            if img_req.HasField("custom_params"):
-                #If future keyword arguments are added here, they'll need to be added to this call
-                #get_image_and_timestamp already calls a 'sanitized' capture function that handles pre-3.3 blocking_captures
-                captured_image, img_time_seconds = self.image_sources_mapped[
-                    src_name].get_image_and_timestamp(custom_params=img_req.custom_params)
-            else:
-                #get_image_and_timestamp() can accomodate pre-3.3 blocking_capture calls if no custom params are supplied
-                captured_image, img_time_seconds = self.image_sources_mapped[
-                    src_name].get_image_and_timestamp()
-
-            if captured_image is None or img_time_seconds is None:
-                img_resp.status = image_pb2.ImageResponse.STATUS_IMAGE_DATA_ERROR
-                error_message = "Failed to capture an image from %s on the server." % src_name
-                response.header.error.message = error_message
-                self.logger.warning(error_message)
-                continue
-
-            # Convert the image capture time from the local clock time into the robot's time. Then set it as
-            # the acquisition timestamp for the image data.
-            img_resp.shot.acquisition_time.CopyFrom(
-                self.bosdyn_sdk_robot.time_sync.robot_timestamp_from_local_secs(img_time_seconds))
-
-            img_resp.shot.image.rows = img_resp.source.rows
-            img_resp.shot.image.cols = img_resp.source.cols
-
-            # Set the image data.
-            img_resp.shot.image.format = img_req.image_format
-            decode_status = self._set_format_and_decode(captured_image, img_resp.shot.image,
-                                                        img_req)
-            if decode_status != image_pb2.ImageResponse.STATUS_OK:
-                img_resp.status = decode_status
-
-            # Set that we successfully got the image.
-            if img_resp.status == image_pb2.ImageResponse.STATUS_UNKNOWN:
-                img_resp.status = image_pb2.ImageResponse.STATUS_OK
-
-        # No header error codes, so set the response header as CODE_OK.
-        populate_response_header(response, request)
+                img_resp.shot.image.rows = img_resp.source.rows
+                img_resp.shot.image.cols = img_resp.source.cols
+
+                # Set the image data.
+                img_resp.shot.image.format = img_req.image_format
+                decode_status = self._set_format_and_decode(captured_image, img_resp.shot.image,
+                                                            img_req)
+                if decode_status != image_pb2.ImageResponse.STATUS_OK:
+                    img_resp.status = decode_status
+
+                # Set that we successfully got the image.
+                if img_resp.status == image_pb2.ImageResponse.STATUS_UNKNOWN:
+                    img_resp.status = image_pb2.ImageResponse.STATUS_OK
+
+            # No header error codes, so set the response header as CODE_OK.
+            populate_response_header(response, request)
         return response
 
     def __del__(self):

bosdyn/client/log_status.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.
 """Client for the log-status service.
 
 This allows client code to start, extend or terminate experiment logs and start retro logs.
@@ -183,6 +185,7 @@ class LogStatusClient(BaseClient):
                                **kwargs)
 
 
+
 _GET_LOG_STATUS_STATUS_TO_ERROR = \
     collections.defaultdict(lambda: (LogStatusResponseError, None))
 _GET_LOG_STATUS_STATUS_TO_ERROR.update({
@@ -232,6 +235,7 @@ _TERMINATE_LOG_STATUS_TO_ERROR.update({
 })
 
 
+
 @handle_common_header_errors
 @handle_unset_status_error(unset='STATUS_UNKNOWN')
 def get_log_status_error(response):
@@ -284,3 +288,5 @@ def terminate_log_error(response):
     return error_factory(response, response.status,
                          status_to_string=log_status.TerminateLogResponse.Status.Name,
                          status_to_error=_TERMINATE_LOG_STATUS_TO_ERROR)
+
+

bosdyn/client/math_helpers.py

@@ -408,6 +408,10 @@ class SE2Velocity(object):
                     + str(se2_vel_vector.shape[0]))
                 return None
             else:
+                if (isinstance(se2_vel_vector[0], numpy.ndarray)):
+                    return SE2Velocity(x=se2_vel_vector[0][0], y=se2_vel_vector[1][0],
+                                       angular=se2_vel_vector[2][0])
+
                 return SE2Velocity(x=se2_vel_vector[0], y=se2_vel_vector[1],
                                    angular=se2_vel_vector[2])
 
@@ -521,6 +525,11 @@ class SE3Velocity(object):
                     + str(se3_vel_vector.shape[0]))
                 return None
             else:
+                if (isinstance(se3_vel_vector[0], numpy.ndarray)):
+                    return SE3Velocity(lin_x=se3_vel_vector[0][0], lin_y=se3_vel_vector[1][0],
+                                       lin_z=se3_vel_vector[2][0], ang_x=se3_vel_vector[3][0],
+                                       ang_y=se3_vel_vector[4][0], ang_z=se3_vel_vector[5][0])
+
                 return SE3Velocity(lin_x=se3_vel_vector[0], lin_y=se3_vel_vector[1],
                                    lin_z=se3_vel_vector[2], ang_x=se3_vel_vector[3],
                                    ang_y=se3_vel_vector[4], ang_z=se3_vel_vector[5])
@@ -1100,6 +1109,11 @@ def skew_matrix_2d(vec2_proto):
     return numpy.array([[vec2_proto.y, -vec2_proto.x]])
 
 
+def matrix_from_proto(proto):
+    """Converts a geometry_pb2.Matrix or geometry_pb2.Matrixf to a numpy array."""
+    return numpy.array(proto.values).reshape(proto.rows, proto.cols)
+
+
 def transform_se2velocity(a_adjoint_b_matrix, se2_velocity_in_b):
     """
     Changes the frame that the SE(2) Velocity is expressed in. More specifically, it converts the
@@ -1162,4 +1176,4 @@ def quat_to_eulerZYX(q):
         yaw = math.atan2(2 * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z)
         roll = math.atan2(2 * (q.y * q.z + q.w * q.x),
                           q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z)
-    return yaw, pitch, roll
+    return yaw, pitch, roll

bosdyn/client/payload_software_update.py

@@ -0,0 +1,185 @@
+# 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).
+
+"""Payload software update service gRPC client.
+
+This is used by Spot payloads to coordinate updates of their own software with Spot.
+"""
+
+import datetime
+
+from google.protobuf import timestamp_pb2
+
+from bosdyn.api.payload_software_update_pb2 import (GetAvailableSoftwareUpdatesRequest,
+                                                    SendCurrentVersionInfoRequest,
+                                                    SendSoftwareUpdateStatusRequest)
+from bosdyn.api.payload_software_update_service_pb2_grpc import PayloadSoftwareUpdateServiceStub
+from bosdyn.api.robot_id_pb2 import SoftwareVersion
+from bosdyn.api.software_package_pb2 import SoftwarePackageVersion, SoftwareUpdateStatus
+from bosdyn.client.common import BaseClient
+
+
+class PayloadSoftwareUpdateClient(BaseClient):
+    """A client for payloads to coordinate software updates with a robot."""
+
+    default_service_name = 'payload-software-update'
+    service_type = 'bosdyn.api.PayloadSoftwareUpdateService'
+
+    def __init__(self):
+        super(PayloadSoftwareUpdateClient, self).__init__(PayloadSoftwareUpdateServiceStub)
+
+    def send_current_software_info(
+            self, package_name: str, version: SoftwareVersion | list[int],
+            release_date: float | timestamp_pb2.Timestamp | datetime.datetime, build_id: str,
+            **kwargs):
+        """Send version information about the currently installed payload software to Spot.
+
+        Args:
+            package_name: Name of the package, e.g., "coreio"
+            version: Current semantic version of the installed software.
+            release_date: Release date of the currently installed software.
+            build_id: Unique identifier of the build.
+
+        Returns:
+            SendCurrentVersionInfoResponse: The response object from Spot. Currently this message
+                contains no information other than a standard response header.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        request = self.make_info_request(package_name, version, release_date, build_id)
+        return self.call(self._stub.SendCurrentVersionInfo, request, **kwargs)
+
+    def send_current_software_info_async(
+            self, package_name: str, version: SoftwareVersion | list[int],
+            release_date: float | timestamp_pb2.Timestamp | datetime.datetime, build_id: str,
+            **kwargs):
+        """Async version of send_current_software_info().
+
+        Args:
+            package_name: Name of the package, e.g., "coreio"
+            version: Current semantic version of the installed software.
+            release_date: Release date of the currently installed software.
+            build_id: Unique identifier of the build.
+
+        Returns:
+            SendCurrentVersionInfoResponse: The response object from Spot. Currently this message
+                contains no information other than a standard response header.
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        request = self.make_info_request(package_name, version, release_date, build_id)
+        return self.call_async(self._stub.SendCurrentVersionInfo, request, **kwargs)
+
+    def get_available_updates(self, package_names: str | list[str], **kw_args):
+        """Get a list of package information for the named package(s).
+
+        Args:
+            package_names: The package name or list of package names to query.
+
+        Returns:
+            GetAvailableSoftwareUpdatesResponse: The response object from Spot containing the
+                version info for packages cached by Spot.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        if not isinstance(package_names, list):
+            package_names = [package_names]
+        request = GetAvailableSoftwareUpdatesRequest(package_names=package_names)
+        return self.call(self._stub.GetAvailableSoftwareUpdates, request, **kw_args)
+
+    def get_available_updates_async(self, package_names: str | list[str], **kw_args):
+        """Async version of get_available_updates().
+
+        Args:
+            package_names: The package name or list of package names to query.
+
+        Returns:
+            GetAvailableSoftwareUpdatesResponse: The response object from Spot containing the
+                version info for packages cached by Spot.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        if not isinstance(package_names, list):
+            package_names = [package_names]
+        request = GetAvailableSoftwareUpdatesRequest(package_names=package_names)
+        return self.call_async(self._stub.GetAvailableSoftwareUpdates, request, **kw_args)
+
+    def send_installation_status(self, package_name: str, status: SoftwareUpdateStatus.Status,
+                                 error_code: SoftwareUpdateStatus.ErrorCode, **kw_args):
+        """Send a status update of a payload software installation operation to Spot.
+
+        Args:
+            package_name: Name of the package being updated
+            status: Status code of installation operation
+            error_code: Error code of the installation operation, or ERROR_NONE if no error has
+                been encountered.
+
+        Returns:
+            SendSoftwareUpdateStatusResponse: The response object from Spot. Currently this message
+                contains nothing beyond a standard response header.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        status = SoftwareUpdateStatus(package_name=package_name, status=status,
+                                      error_code=error_code)
+        request = SendSoftwareUpdateStatusRequest(update_status=status)
+        return self.call(self._stub.SendSoftwareUpdateStatus, request, **kw_args)
+
+    def send_installation_status_async(self, package_name: str, status: SoftwareUpdateStatus.Status,
+                                       error_code: SoftwareUpdateStatus.ErrorCode, **kw_args):
+        """Async version of send_installation_status().
+
+        Args:
+            package_name: Name of the package being updated
+            status: Status code of installation operation
+            error_code: Error code of the installation operation, or ERROR_NONE if no error has
+                been encountered.
+
+        Returns:
+            SendSoftwareUpdateStatusResponse: The response object from Spot. Currently this message
+                contains nothing beyond a standard response header.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        status = SoftwareUpdateStatus(package_name=package_name, status=status,
+                                      error_code=error_code)
+        request = SendSoftwareUpdateStatusRequest(update_status=status)
+        return self.call_async(self._stub.SendSoftwareUpdateStatus, request, **kw_args)
+
+    @staticmethod
+    def make_info_request(package_name: str, version: SoftwareVersion,
+                          release_date: float | timestamp_pb2.Timestamp | datetime.datetime,
+                          build_id: str):
+        """Make a SendCurrentVersionInfoRequest message using the supplied information.
+
+        Args:
+            package_name: Name of the package, e.g., "coreio"
+            version: Current semantic version of the installed software.
+            release_date: Release date of the currently installed software.
+            build_id: Unique identifier of the build.
+
+        Returns:
+            SendCurrentVersionInfoRequest: Message communicating to Spot the version information
+                    of the currently installed payload software.
+        """
+        if not isinstance(version, SoftwareVersion):
+            version = SoftwareVersion(major_version=version[0], minor_version=version[1],
+                                      patch_level=version[2])
+        if isinstance(release_date, float):
+            release_date = datetime.datetime.fromtimestamp(release_date)
+        if isinstance(release_date, datetime.datetime):
+            pb_release_date = timestamp_pb2.Timestamp()
+            pb_release_date.FromDatetime(release_date)
+            release_date = pb_release_date
+
+        return SendCurrentVersionInfoRequest(
+            package_version=SoftwarePackageVersion(package_name=package_name, version=version,
+                                                   release_date=release_date, build_id=build_id))

bosdyn/client/payload_software_update_initiation.py

@@ -0,0 +1,79 @@
+# 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).
+
+"""Payload software update initiation gRPC client.
+
+This client uses an insecure channel for signaling to a payload that it should
+send its version information or initiate a software update.
+"""
+
+from bosdyn.api.payload_software_update_initiation_pb2 import (
+    TriggerInitiateUpdateRequest, TriggerSendPayloadSoftwareInfoRequest)
+from bosdyn.api.payload_software_update_initiation_service_pb2_grpc import \
+    PayloadSoftwareUpdateInitiationServiceStub
+from bosdyn.client.common import BaseClient
+
+
+class PayloadSoftwareUpdateInitiationClient(BaseClient):
+    """A client used to direct a payload to send its version information or start an update."""
+
+    def __init__(self):
+        super(PayloadSoftwareUpdateInitiationClient,
+              self).__init__(PayloadSoftwareUpdateInitiationServiceStub)
+
+    default_service_name = 'payload-software-update-initiation'
+    service_type = 'bosdyn.api.PayloadSoftwareUpdateInitiationService'
+
+    def trigger_send_payload_software_info(self, **kwargs):
+        """Tell a payload to send its current version information to Spot.
+
+        Returns:
+            TriggerSendPayloadSoftwareInfoResponse: The response object from the payload. Currently
+                this message is empty.
+
+        Raises:
+            RpcError: Problem communicating with the payload.
+        """
+        return self.call(self._stub.TriggerSendPayloadSoftwareInfo,
+                         TriggerSendPayloadSoftwareInfoRequest(), **kwargs)
+
+    def trigger_send_payload_software_info_async(self, **kwargs):
+        """Async version of trigger_send_payload_software_info().
+
+        Returns:
+            TriggerSendPayloadSoftwareInfoResponse: The response object from the payload. Currently
+                this message is empty.
+
+        Raises:
+            RpcError: Problem communicating with the payload.
+        """
+        return self.call_async(self._stub.TriggerSendPayloadSoftwareInfo,
+                               TriggerSendPayloadSoftwareInfoRequest(), **kwargs)
+
+    def trigger_initiate_update(self, **kwargs):
+        """Tell a payload to initiate its software update logic.
+
+        Returns:
+            TriggerInitiateUpdateResponse: The response object from the payload. Currently this
+                message is empty.
+
+        Raises:
+            RpcError: Problem communicating with the payload.
+        """
+        return self.call(self._stub.TriggerInitiateUpdate, TriggerInitiateUpdateRequest(), **kwargs)
+
+    def trigger_initiate_update_async(self, **kwargs):
+        """Async version of trigger_initiate_update().
+
+        Returns:
+            TriggerInitiateUpdateResponse: The response object from the payload. Currently this
+                message is empty.
+
+        Raises:
+            RpcError: Problem communicating with the payload.
+        """
+        return self.call_async(self._stub.TriggerInitiateUpdate, TriggerInitiateUpdateRequest(),
+                               **kwargs)

bosdyn/client/point_cloud.py

@@ -39,6 +39,10 @@ class PointCloudDataError(PointCloudResponseError):
     """System cannot generate point cloud data at this time."""
 
 
+class PointCloudTypeError(PointCloudResponseError):
+    """System cannot generate point cloud with the request cloud_type."""
+
+
 _STATUS_TO_ERROR = collections.defaultdict(lambda: (PointCloudResponseError, None))
 _STATUS_TO_ERROR.update({
     point_cloud_protos.PointCloudResponse.STATUS_OK: (None, None),
@@ -50,6 +54,8 @@ _STATUS_TO_ERROR.update({
         error_pair(UnsetStatusError),
     point_cloud_protos.PointCloudResponse.STATUS_POINT_CLOUD_DATA_ERROR:
         error_pair(PointCloudDataError),
+    point_cloud_protos.PointCloudResponse.STATUS_UNSUPPORTED_CLOUD_TYPE:
+        error_pair(PointCloudTypeError),
 })
 
 
@@ -66,6 +72,8 @@ def _error_from_response(response):
     return None
 
 
+
+
 class PointCloudClient(BaseClient):
     """A client handling point clouds."""
 
@@ -177,6 +185,7 @@ class PointCloudClient(BaseClient):
         return point_cloud_protos.ListPointCloudSourcesRequest()
 
 
+
 def build_pc_request(point_cloud_source_name):
     """Helper function which builds an PointCloudRequest from a point cloud source name.
 

bosdyn/client/robot.py

@@ -385,7 +385,7 @@ class Robot(object):
         self.update_user_token(user_token, username)
 
     def authenticate_from_payload_credentials(self, guid, secret, payload_registration_client=None,
-                                              timeout=None):
+                                              timeout=None, retry_interval=1.0):
         """Authenticate to this Robot with the guid/secret of the hosting payload.
 
         This call is used to authenticate to a robot using payload credentials. If a payload is
@@ -413,7 +413,7 @@ class Robot(object):
                     self.logger.warning(
                         'Payload is not authorized. Authentication will block until an'
                         ' operator authorizes the payload in the Admin Console.')
-            time.sleep(0.1)
+            time.sleep(retry_interval)
         self.update_user_token(user_token)
 
     def update_user_token(self, user_token, username=None):
@@ -467,7 +467,8 @@ class Robot(object):
         return self.service_type_by_name
 
 
-    def register_payload_and_authenticate(self, payload, secret, timeout=None):
+    def register_payload_and_authenticate(self, payload, secret, timeout=None,
+                                          auth_retry_interval=1.0):
         """Register a payload with the robot and request a user_token.
 
         This method will block until the payload is authorized by an operator in the robot webpage.
@@ -486,7 +487,7 @@ class Robot(object):
             pass
         self.authenticate_from_payload_credentials(
             payload.GUID, secret, payload_registration_client=payload_registration_client,
-            timeout=timeout)
+            timeout=timeout, retry_interval=auth_retry_interval)
 
     def start_time_sync(self, time_sync_interval_sec=None):
         """Start time sync thread if needed.

bosdyn/client/sdk.py

@@ -8,13 +8,13 @@
 
 import datetime
 import glob
+import importlib.resources
 import logging
 import os
 import platform
 from enum import Enum
 
 import jwt
-import pkg_resources
 from deprecated.sphinx import deprecated
 
 from .arm_surface_contact import ArmSurfaceContactClient
@@ -178,6 +178,8 @@ def create_standard_sdk(client_name_prefix, service_clients=None, cert_resource_
 
 
 
+
+
 class Sdk(object):
     """Repository for settings typically common to a single developer and/or robot fleet.
     See also Robot for robot-specific settings.
@@ -281,7 +283,7 @@ class Sdk(object):
         """
         self.cert = None
         if resource_path_glob is None:
-            self.cert = pkg_resources.resource_stream('bosdyn.client.resources', 'robot.pem').read()
+            self.cert = importlib.resources.read_binary('bosdyn.client.resources', 'robot.pem')
         else:
             cert_paths = [c for c in glob.glob(resource_path_glob) if os.path.isfile(c)]
             if not cert_paths: