bosdyn-client 4.1.1__py3-none-any.whl → 5.0.1__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/keepalive.py

@@ -19,6 +19,7 @@ import bosdyn.util
 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
 
 
@@ -225,7 +226,7 @@ class PolicyKeepalive():
     #pylint: disable=too-many-arguments
     def __init__(self, client: KeepaliveClient, policy: Policy, rpc_timeout_seconds: float = None,
                  rpc_interval_seconds: float = None, logger: 'logging.Logger' = None,
-                 remove_policy_on_exit: bool = False):
+                 remove_policy_on_exit: bool = False, initial_retry_seconds: float = 1.0):
 
         self.logger = logger or logging.getLogger()
         self.remove_policy_on_exit = remove_policy_on_exit
@@ -238,6 +239,11 @@ class PolicyKeepalive():
         # This will raise an exception if there's no action at all.
         self._rpc_interval_seconds = rpc_interval_seconds or policy.shortest_action_delay() / 3
         self._rpc_timeout_seconds = rpc_timeout_seconds
+        self._initial_retry_seconds = initial_retry_seconds
+
+        #: Callable[[Exception], ErrorCallbackResult] | None: Optional callback to be called when
+        #: an error occurs in the keepalive thread.
+        self.keepalive_error_callback = None
 
         self._end_check_in_signal = threading.Event()
         self._thread = threading.Thread(target=self._periodic_check_in)
@@ -277,24 +283,47 @@ class PolicyKeepalive():
         self._end_check_in_signal.set()
 
     def _periodic_check_in(self):
-        while True:
+        retry_interval = self._initial_retry_seconds
+        wait_time = self._rpc_interval_seconds
+
+        # Block and wait for the stop signal. If we receive it within the check-in period,
+        # 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()
+            action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
 
             try:
                 self._check_in()
             except RetryableRpcError as exc:
                 self.logger.warning('exception during check-in:\n%s\n', exc)
                 self.logger.info('continuing check-in')
-
+            except Exception as exc:  # pylint: disable=broad-except
+                if self.keepalive_error_callback is not None:
+                    action = ErrorCallbackResult.DEFAULT_ACTION
+                    try:
+                        action = self.keepalive_error_callback(exc)
+                    except Exception:  # pylint: disable=broad-except
+                        self.logger.exception(
+                            'Exception thrown in the provided keepalive error callback')
+                else:
+                    raise
             # How long did the RPC and processing of said RPC take?
             exec_seconds = time.time() - 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!
-            # Wait up to self._check_in_period seconds, minus the RPC processing time.
-            # (values < 0 are OK and will return immediately)
-            if self._end_check_in_signal.wait(self._rpc_interval_seconds - exec_seconds):
+            if action == ErrorCallbackResult.ABORT:
+                self.logger.warning('Callback directed the keepalive thread to exit.')
                 break
+            elif action == ErrorCallbackResult.RETRY_IMMEDIATELY:
+                wait_time = 0
+                continue
+            elif action == ErrorCallbackResult.RETRY_WITH_EXPONENTIAL_BACK_OFF:
+                wait_time = retry_interval - exec_seconds
+                retry_interval = min(2 * retry_interval, self._rpc_interval_seconds)
+            else:
+                # Success path, or default action (resume normal operation)
+                wait_time = self._rpc_interval_seconds - exec_seconds
+                retry_interval = self._initial_retry_seconds
         self.logger.info('Policy check-in stopped')
 
 

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])
@@ -651,6 +660,10 @@ class SE3Pose(object):
         ret[0:3, 3] = [self.x, self.y, self.z]
         return ret
 
+    def translation_norm(self):
+        """Calculates the Euclidean norm (magnitude) of the translation component pose."""
+        return math.sqrt(self.x**2 + self.y**2 + self.z**2)
+
     def mult(self, se3pose):
         """
         Computes the multiplication between the current math_helpers.SE3Pose and the input se3pose.
@@ -1100,6 +1113,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

bosdyn/client/payload_registration.py

@@ -20,6 +20,7 @@ from bosdyn.client import (ResponseError, RetryableUnavailableError, TimedOutErr
                            TooManyRequestsError)
 from bosdyn.client.common import (BaseClient, error_factory, handle_common_header_errors,
                                   handle_lease_use_result_errors, handle_unset_status_error)
+from bosdyn.client.error_callback_result import ErrorCallbackResult
 
 LOGGER = logging.getLogger('payload_registration_client')
 
@@ -381,16 +382,23 @@ class PayloadRegistrationKeepAlive(object):
           class name is acquired.
       rpc_timeout_secs: Number of seconds to wait for a pay_reg_client RPC. Defaults to None,
           for no timeout.
+      initial_retry_seconds: Number of seconds to wait before retrying registration that failed
+          due to unhandled errors including RPC transport issues.
     """
 
     def __init__(self, pay_reg_client, payload, secret, registration_interval_secs=30, logger=None,
-                 rpc_timeout_secs=None):
+                 rpc_timeout_secs=None, initial_retry_seconds=1.0):
         self.pay_reg_client = pay_reg_client
         self.payload = payload
         self.secret = secret
         self._registration_interval_secs = registration_interval_secs
         self.logger = logger or logging.getLogger(self.__class__.__name__)
         self._rpc_timeout_secs = rpc_timeout_secs
+        self._initial_retry_seconds = initial_retry_seconds
+
+        #: Callable[[Exception], ErrorCallbackResult] | None: Optional callback to be called when
+        #: an error occurs in the re-registration thread.
+        self.reregistration_error_callback = None
 
         # Configure the thread to do re-registration.
         self._end_reregister_signal = threading.Event()
@@ -423,6 +431,7 @@ class PayloadRegistrationKeepAlive(object):
 
         # This will raise an exception if the thread has already started.
         self._thread.start()
+        return self
 
     def is_alive(self):
         """Are we still periodically re-registering?
@@ -445,8 +454,12 @@ class PayloadRegistrationKeepAlive(object):
           RpcError: Problem communicating with the robot.
         """
         self.logger.info('Starting registration loop')
-        while True:
+        retry_interval = self._initial_retry_seconds
+        wait_time = self._registration_interval_secs
+
+        while not self._end_reregister_signal.wait(wait_time):
             exec_start = time.time()
+            action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
             try:
                 self.pay_reg_client.register_payload(self.payload, self.secret)
             except PayloadAlreadyExistsError:
@@ -459,10 +472,31 @@ class PayloadRegistrationKeepAlive(object):
                 self.logger.warning('Timed out, timeout set to "{}"'.format(self._rpc_timeout_secs))
             except TooManyRequestsError:
                 self.logger.warning("Too many requests error")
-            except Exception as exc:
-                # Log all other exceptions, but continue looping in hopes that it resolves itself
-                self.logger.exception('Caught general exception.')
+            except Exception as exc:  # pylint: disable=broad-except
+                # If the application provided an error handler, give it an opportunity to resolve
+                # the issue.
+                if self.reregistration_error_callback is not None:
+                    action = ErrorCallbackResult.DEFAULT_ACTION
+                    try:
+                        action = self.reregistration_error_callback(exc)
+                    except Exception:  # pylint: disable=broad-except
+                        self.logger.exception(
+                            'Exception thrown in the provided re-registration error callback ')
+                else:
+                    # Log all other exceptions, but continue looping in hopes that it resolves itself
+                    self.logger.exception('Caught general exception.')
+
             exec_sec = time.time() - exec_start
-            if self._end_reregister_signal.wait(self._registration_interval_secs - exec_sec):
+            if action == ErrorCallbackResult.ABORT:
+                self.logger.warning('Callback directed the re-registration loop to exit.')
                 break
+            elif action == ErrorCallbackResult.RETRY_IMMEDIATELY:
+                wait_time = 0.0
+            elif action == ErrorCallbackResult.RETRY_WITH_EXPONENTIAL_BACK_OFF:
+                wait_time = retry_interval - exec_sec
+                retry_interval = min(retry_interval * 2, self._registration_interval_secs)
+            else:
+                # Success path, or default action (resume normal operation)
+                wait_time = self._registration_interval_secs - exec_sec
+                retry_interval = self._initial_retry_seconds
         self.logger.info('Re-registration stopped')

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))