bosdyn-client 3.3.2__py3-none-any.whl → 4.0.1__py3-none-any.whl

bosdyn/client/image.py

@@ -7,6 +7,7 @@
 """For clients to use the image service."""
 import collections
 import os
+import warnings
 
 import numpy as np
 
@@ -336,7 +337,8 @@ def pixel_to_camera_space(image_proto, pixel_x, pixel_y, depth=1.0):
     the (u,v) pixel coordinates.
 
     Args:
-        image_proto (image_pb2.Image): The image in which the pixel coordinates are from
+        image_proto (image_pb2.ImageSource): The image source proto which the pixel coordinates are from.
+            Use of image_pb2.ImageCaptureAndSource or image_pb2.ImageResponse types here have been deprecated.
         pixel_x (int): x-coordinate.
         pixel_y (int): y-coordinate.
         depth (double): The depth from the camera to the point of interest.
@@ -345,14 +347,25 @@ def pixel_to_camera_space(image_proto, pixel_x, pixel_y, depth=1.0):
         An (x,y,z) tuple representing the pixel point of interest now described as a point
         in the camera frame.
     """
-    if not image_proto.source.HasField('pinhole'):
+    if 'source' in image_proto.ListFields() or isinstance(
+            image_proto, image_pb2.ImageResponse) or isinstance(image_proto,
+                                                                image_pb2.ImageCaptureAndSource):
+        warnings.warn(
+            "Use of image_pb2.ImageCaptureAndSource or image_pb2.ImageResponse types for image_proto"
+            " argument have been deprecated, use image_pb2.ImageSource instead. version=4.0.0",
+            DeprecationWarning, stacklevel=2)
+        image_source = image_proto.source
+    else:
+        image_source = image_proto
+
+    if not image_source.HasField('pinhole'):
         raise ValueError('Requires a pinhole camera_model.')
 
-    focal_x = image_proto.source.pinhole.intrinsics.focal_length.x
-    principal_x = image_proto.source.pinhole.intrinsics.principal_point.x
+    focal_x = image_source.pinhole.intrinsics.focal_length.x
+    principal_x = image_source.pinhole.intrinsics.principal_point.x
 
-    focal_y = image_proto.source.pinhole.intrinsics.focal_length.y
-    principal_y = image_proto.source.pinhole.intrinsics.principal_point.y
+    focal_y = image_source.pinhole.intrinsics.focal_length.y
+    principal_y = image_source.pinhole.intrinsics.principal_point.y
 
     x_rt_camera = depth * (pixel_x - principal_x) / focal_x
     y_rt_camera = depth * (pixel_y - principal_y) / focal_y
@@ -403,7 +416,7 @@ def depth_image_to_pointcloud(image_response, min_dist=0, max_dist=1000):
     """Converts a depth image into a point cloud using the camera intrinsics. The point
     cloud is represented as a numpy array of (x,y,z) values.  Requests can optionally filter
     the results based on the points distance to the image plane. A depth image is represented
-    with an unsigned 16 bit integer and a scale factor to convert that distance to meters. In
+    with an unsigned 16-bit integer and a scale factor to convert that distance to meters. In
     addition, values of zero and 2^16 (uint 16 maximum) are used to represent invalid indices.
     A (min_dist * depth_scale) value that casts to an integer value <=0 will be assigned a
     value of 1 (the minimum representational distance). Similarly, a (max_dist * depth_scale)

bosdyn/client/image_service_helpers.py

@@ -65,9 +65,9 @@ class CameraInterface(ABC):
         threads/requests may try to call blocking_capture at the same time. A Lock (self.capture_lock) is provided
         as a convenience to help with this.
 
-        Keyword Args:
+        Args:
             custom_params (service_customization_pb2.DictParam): Custom parameters defined by the image source
-                                                                 affecting the resulting capture 
+                                                                 affecting the resulting capture
             **kwargs: Other keyword arguments including future additions to the request that affect the capture.
                       If an implementer is looking to use kwargs, it is expected that they update their
                       blocking_capture function signature to accept named keyword arguments such as custom_params
@@ -181,7 +181,7 @@ class VisualImageSource():
 
     def create_capture_thread(self, custom_params=None):
         """Initialize a background thread to continuously capture images.
-        
+
         """
         self.capture_thread = ImageCaptureThread(self.image_source_name, self.capture_function,
                                                  custom_params=custom_params)
@@ -277,7 +277,7 @@ class VisualImageSource():
         Args:
             capture_func (CameraInterface.blocking_capture): The function capturing the image
                                                               data and timestamp.
-            custom_params (service_customization_pb2.DictParam): Custom parameters passed to the blocking 
+            custom_params (service_customization_pb2.DictParam): Custom parameters passed to the blocking
                                                                  capture affecting the resulting capture
             **capture_func_kwargs: Other keyword arguments for the capture_func
         """
@@ -309,7 +309,7 @@ class VisualImageSource():
         """Retrieve the latest captured image and timestamp.
 
         Args:
-            custom_params (service_customization_pb2.DictParam): Custom parameters passed to the object's 
+            custom_params (service_customization_pb2.DictParam): Custom parameters passed to the object's
                                                                  capture_function affecting the resulting capture
             **capture_func_kwargs: Other keyword arguments for the capture_function
 
@@ -343,7 +343,7 @@ class VisualImageSource():
             image_req (image_pb2.ImageRequest): The image request associated with the image_data.
 
         Returns:
-            image_pb2.ImageResponse.Status indicating if the decode succeeds, or image format conversion or
+            image_pb2.ImageResponse.Status indicating if the decoding succeeds, or image format conversion or
             pixel conversion failed. Throws a decode data fault if the image or
             pixels cannot be decoded to the desired format. Mutates the image_proto Image proto
             with the decoded data if successful.
@@ -402,7 +402,7 @@ class VisualImageSource():
             image_type (image_pb2.ImageType): The type of image (e.g. visual, depth).
             image_formats (image_pb2.Image.Format): The image formats supported (jpeg, raw)
             pixel_formats (image_pb2.Image.PixelFormat): The pixel formats supported
-            param_spec (service_customization_pb2.DictParam.Spec): A set of custom parameters 
+            param_spec (service_customization_pb2.DictParam.Spec): A set of custom parameters
                                                                    passed into this image source
         Returns:
             An ImageSource with the cols, rows, and image type populated.
@@ -431,7 +431,7 @@ class VisualImageSource():
                                      which returns the gain as a float.
             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_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
         Returns:
             An instance of the protobuf CaptureParameters message.
@@ -457,11 +457,11 @@ class VisualImageSource():
 class ThreadCaptureOutput:
     """Small struct to represent the output of an ImageCaptureThread's get_latest_captured_image
     in a future-compatible way
-    
+
     Args:
         is_valid (Boolean): Whether the latest capture uses the custom parameters and other arguments
                             supplied in the latest request, and is therefore returned
-        image (Any | None): If the latest capture is valid, the image data in any format 
+        image (Any | None): If the latest capture is valid, the image data in any format
                             (e.g. numpy, bytes, array)
         timestamp (float): The timestamp that the latest valid capture was taken
     """
@@ -547,7 +547,7 @@ class ImageCaptureThread():
             self.has_updated_capture = True
 
     def get_latest_captured_image(self, custom_params=None, **capture_func_kwargs):
-        """Returns the last found image and timestamp in a ThreadCaptureOutput object if that 
+        """Returns the last found image and timestamp in a ThreadCaptureOutput object if that
             image uses the latest params. Otherwise returns a ThreadCaptureOutput object with
             is_valid = False and capture/timestamp as None.
         """
@@ -567,8 +567,8 @@ class ImageCaptureThread():
         # Still, check for the custom_params argument to ensure we accomodate 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
-            output_capture_function = lambda: capture_func(custom_params=custom_params, **
-                                                           capture_func_kwargs)
+            def output_capture_function():
+                return capture_func(custom_params=custom_params, **capture_func_kwargs)
         else:
             output_capture_function = capture_func
         return output_capture_function
@@ -664,7 +664,7 @@ class CameraBaseImageServicer(image_service_pb2_grpc.ImageServiceServicer):
         return response
 
     def _set_format_and_decode(self, image_data, img_proto, img_req):
-        """Calls the image_decode_with_error_checking function, which returns a (Boolean, Boolean) if the decode succeeds."""
+        """Calls the image_decode_with_error_checking function, which returns a (Boolean, Boolean) if the decoding succeeds."""
         # This function should set the image data, pixel format, image format, and transform snapshot fields.
         return self.image_sources_mapped[
             img_req.image_source_name].image_decode_with_error_checking(

bosdyn/client/lease.py

@@ -52,7 +52,7 @@ class ResourceAlreadyClaimedError(LeaseResponseError):
 
 
 class RevokedLeaseError(LeaseResponseError):
-    """Lease is stale because the lease holder did not check in regularly enough."""
+    """Lease is stale because the lease-holder did not check in regularly enough."""
 
 
 class UnmanagedResourceError(LeaseResponseError):
@@ -135,14 +135,11 @@ class Lease(object):
 
     Args:
         lease_proto: bosdyn.api.Lease protobuf object.
+    Raises:
+        ValueError if lease_proto is not present or valid.
     """
 
     def __init__(self, lease_proto, ignore_is_valid_check=False):
-        """Initializes a Lease object.
-
-        Raises:
-            ValueError if lease_proto is not present or valid.
-        """
         if not ignore_is_valid_check and not self.is_valid_proto(lease_proto):
             raise ValueError('invalid lease_proto: {}'.format(lease_proto))
         self.lease_proto = lease_proto
@@ -289,6 +286,17 @@ class Lease(object):
 
 
 class LeaseState(object):
+    """State of lease ownership in the wallet.
+
+    Args:
+        lease_status(LeaseState.Status): The ownership status of the lease.
+        lease_owner(lease_pb2.LeaseOwner): The name of the owner of the lease.
+        lease (Lease): The original lease used to initialize the LeaseState, before
+                       applying any subleasing/incrementing.
+        lease_current(Lease): The newest version of the lease (subleased, and
+                              incremented from the original lease).
+        client_name(string): The name of the client using this lease.
+    """
 
     class Status(enum.Enum):
         UNOWNED = 0
@@ -306,16 +314,7 @@ class LeaseState(object):
 
     def __init__(self, lease_status, lease_owner=None, lease=None, lease_current=None,
                  client_name=None):
-        """
-        Args:
-            lease_status(LeaseState.Status): The ownership status of the lease.
-            lease_owner(lease_pb2.LeaseOwner): The name of the owner of the lease.
-            lease (Lease): The original lease used to initialize the LeaseState, before
-                           applying any subleasing/incrementing.
-            lease_current(Lease): The newest version of the lease (subleased, and
-                                  incremented from the original lease).
-            client_name(string): The name of the client using this lease.
-        """
+
         self.lease_status = lease_status
         self.lease_owner = lease_owner
         self.lease_original = lease
@@ -349,10 +348,16 @@ class LeaseState(object):
         """
         if lease_use_result.status == lease_use_result.STATUS_OLDER:
             if self.lease_current:
-                attempted_lease = Lease(lease_use_result.attempted_lease)
-                if attempted_lease.compare(self.lease_current) is Lease.CompareResult.SAME:
-                    return LeaseState(LeaseState.Status.OTHER_OWNER,
-                                      lease_owner=lease_use_result.owner)
+                latest_known_lease = Lease(lease_use_result.latest_known_lease)
+                if latest_known_lease.is_valid_lease():
+                    cmp = self.lease_current.compare(latest_known_lease)
+                    if cmp is Lease.CompareResult.NEWER or cmp is Lease.CompareResult.SAME:
+                        # The attempted lease was older, but the lease in the wallet has been updated
+                        # in the meantime to something that is newer than what the robot has seen, so
+                        # this OLDER result is no longer relevant.
+                        return self
+                # The lease from the lease wallet was an older lease.
+                return LeaseState(LeaseState.Status.OTHER_OWNER, lease_owner=lease_use_result.owner)
         elif lease_use_result.status == lease_use_result.STATUS_WRONG_EPOCH:
             if self.lease_current:
                 attempted_lease = Lease(lease_use_result.attempted_lease)
@@ -837,10 +842,10 @@ def add_lease_wallet_processors(client, lease_wallet, resource_list=None):
 class LeaseKeepAlive(object):
     """LeaseKeepAlive issues lease liveness checks on a background thread.
 
-    The robot's lease system expects lease holders to check in at a regular
+    The robot's lease system expects lease-holders to check in at a regular
     cadence. If the check-ins do not happen, the robot will treat it as a
     communications loss. Typically this will result in the robot stopping,
-    powering off, and the lease holder getting their lease revoked.
+    powering off, and the lease-holder getting their lease revoked.
 
     Using a LeaseKeepAlive object hides most of the details of issuing the
     lease liveness check. Developers can also manage liveness checks directly

bosdyn/client/lease_validator.py

@@ -268,13 +268,13 @@ class LeaseValidator:
 
 class LeaseValidatorResponseProcessor:  # pylint: disable=too-few-public-methods
     """LeaseValidatorResponseProcessor updates the lease validator using the
-    latest_known_lease from the response's LeaseUseResult."""
+    latest_known_lease from the response's LeaseUseResult.
+
+    Args:
+        lease_validator (LeaseValidator): validator for a specific robot to be updated.
+    """
 
     def __init__(self, lease_validator):
-        """
-        Args:
-            lease_validator (LeaseValidator): validator for a specific robot to be updated.
-        """
         self.lease_validator = lease_validator
 
     def mutate(self, response):

bosdyn/client/manipulation_api_client.py

@@ -100,4 +100,4 @@ def _manipulation_api_feedback_error_from_response(response):
 
 @handle_common_header_errors
 def _grasp_override_command_error_from_response(response):
-    return None
+    return None

bosdyn/client/map_processing.py

@@ -34,7 +34,7 @@ class InvalidGraphError(MapProcessingServiceResponseError):
 
 
 class InvalidParamsError(MapProcessingServiceResponseError):
-    """The parameters passed to the optimizer do not make sense (e.g negative weights)."""
+    """The parameters passed to the optimizer do not make sense (e.g. negative weights)."""
 
 
 class MaxIterationsError(MapProcessingServiceResponseError):
@@ -167,11 +167,13 @@ class MapProcessingServiceClient(BaseClient):
 
     @staticmethod
     def _build_process_anchoring_request(params, modify_anchoring_on_server,
-                                         stream_intermediate_results, initial_hint):
+                                         stream_intermediate_results, initial_hint,
+                                         apply_gps_results):
         return map_processing_pb2.ProcessAnchoringRequest(
             params=params, initial_hint=initial_hint,
             modify_anchoring_on_server=modify_anchoring_on_server,
-            stream_intermediate_results=stream_intermediate_results)
+            stream_intermediate_results=stream_intermediate_results,
+            apply_gps_result_to_waypoints_on_server=apply_gps_results)
 
     def process_topology(self, params, modify_map_on_server, **kwargs):
         """Process the topology of the map on the server, closing loops and producing a
@@ -196,7 +198,7 @@ class MapProcessingServiceClient(BaseClient):
                          **kwargs)
 
     def process_anchoring(self, params, modify_anchoring_on_server, stream_intermediate_results,
-                          initial_hint=None, **kwargs):
+                          initial_hint=None, apply_gps_results=False, **kwargs):
         """Process the anchoring of the map on the server, producing a metrically consistent anchoring.
 
         Args:
@@ -208,13 +210,16 @@ class MapProcessingServiceClient(BaseClient):
             iterations may be included in the response. If false, only the last iteration will be returned.
             initial_hint: Initial guess at some number of waypoints and world objects and their anchorings.
             This field is an AnchoringHint object (see map_processing.proto)
+            apply_gps_results: if true, the annotations of waypoints in the graph will be modified to include
+            the pose of each waypoint in a GPS centered frame, if the map has GPS (see map_processing.proto)
         Returns:
             The ProcessAnchoringResponse containing a new optimized anchoring.
         Raises:
             RpcError: Problem communicating with the robot
         """
         request = self._build_process_anchoring_request(params, modify_anchoring_on_server,
-                                                        stream_intermediate_results, initial_hint)
+                                                        stream_intermediate_results, initial_hint,
+                                                        apply_gps_results)
 
         return self.call(self._stub.ProcessAnchoring, request,
                          value_from_response=_get_streamed_anchoring_response,

bosdyn/client/math_helpers.py

@@ -36,7 +36,7 @@ def angle_diff_degrees(a1, a2):
 
 
 class Vec2(object):
-    """Class representing a two dimensional vector."""
+    """Class representing a two-dimensional vector."""
 
     def __init__(self, x, y):
         self.x = x
@@ -115,7 +115,7 @@ class Vec2(object):
 
 
 class Vec3(object):
-    """Class representing a three dimensional vector."""
+    """Class representing a three-dimensional vector."""
 
     def __init__(self, x, y, z):
         self.x = x
@@ -183,6 +183,10 @@ class Vec3(object):
         """Converts the math_helpers.Vec3 into an output of the protobuf geometry_pb2.Vec3."""
         return geometry_pb2.Vec3(x=self.x, y=self.y, z=self.z)
 
+    def to_numpy(self):
+        """Converts the math_helpers.Vec3 into an output of numpy format."""
+        return numpy.array([self.x, self.y, self.z])
+
     def dot(self, other):
         if not isinstance(other, Vec3):
             raise TypeError("Can't dot types %s and %s." % (type(self), type(other)))
@@ -199,6 +203,11 @@ class Vec3(object):
         """Create a math_helpers.Vec3 from a geometry_pb2.Vec3 proto."""
         return Vec3(proto.x, proto.y, proto.z)
 
+    @staticmethod
+    def from_numpy(array):
+        """Create a math_helpers.Vec3 from a numpy array."""
+        return Vec3(array[0], array[1], array[2])
+
 
 class SE2Pose(object):
     """Class representing an SE2Pose with position and angle."""
@@ -382,7 +391,7 @@ class SE2Velocity(object):
     @staticmethod
     def from_vector(se2_vel_vector):
         """Converts a 3x1 velocity vector (of either a numpy array or a list) into a math_helpers.SE2Velocity object."""
-        if type(se2_vel_vector) == list:
+        if isinstance(se2_vel_vector, list):
             if len(se2_vel_vector) != 3:
                 # Must have 3 elements to be a complete SE2Velocity
                 print("Velocity list must have 3 elements. The input has the wrong dimension of: " +
@@ -391,7 +400,7 @@ class SE2Velocity(object):
             else:
                 return SE2Velocity(x=se2_vel_vector[0], y=se2_vel_vector[1],
                                    angular=se2_vel_vector[2])
-        if type(se2_vel_vector) == numpy.ndarray:
+        if isinstance(se2_vel_vector, numpy.ndarray):
             if se2_vel_vector.shape[0] != 3:
                 # Must have 3 elements to be a complete SE2Velocity
                 print(
@@ -494,7 +503,7 @@ class SE3Velocity(object):
     @staticmethod
     def from_vector(se3_vel_vector):
         """Converts a 6x1 velocity vector (of either a numpy array or a list) into a math_helpers.SE3Velocity object."""
-        if type(se3_vel_vector) == list:
+        if isinstance(se3_vel_vector, list):
             if len(se3_vel_vector) != 6:
                 # Must have 6 elements to be a complete SE3Velocity
                 print("Velocity list must have 6 elements. The input has the wrong dimension of: " +
@@ -504,7 +513,7 @@ class SE3Velocity(object):
                 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])
-        if type(se3_vel_vector) == numpy.ndarray:
+        if isinstance(se3_vel_vector, numpy.ndarray):
             if se3_vel_vector.shape[0] != 6:
                 # Must have 6 elements to be a complete SE3Velocity
                 print(
@@ -526,7 +535,7 @@ class SE3Pose(object):
         self.z = z
         # Expect the declaration of math_helpers.SE3Pose to pass a math_helpers.Quat, however we will convert
         # a protobuf Quaternion into the math_helpers object as well.
-        if type(rot) == geometry_pb2.Quaternion:
+        if isinstance(rot, geometry_pb2.Quaternion):
             rot = Quat.from_proto(rot)
         self.rot = rot
 
@@ -676,6 +685,7 @@ class SE3Pose(object):
            for the math_helper.SE3Pose."""
         return geometry_pb2.Vec3(x=self.x, y=self.y, z=self.z)
 
+
     @property
     def rotation(self):
         """Property to allow attribute access of the protobuf message field 'rotation' similar to the geometry_pb2.SE3Pose
@@ -1102,9 +1112,9 @@ def transform_se2velocity(a_adjoint_b_matrix, se2_velocity_in_b):
     Returns:
         math_helpers.SE2Velocity described in frame a. None if the input velocity is an unknown type.
     """
-    if type(se2_velocity_in_b) == geometry_pb2.SE2Velocity:
+    if isinstance(se2_velocity_in_b, geometry_pb2.SE2Velocity):
         se2_velocity_in_b_vector = (SE2Velocity.from_proto(se2_velocity_in_b)).to_vector()
-    elif type(se2_velocity_in_b) == SE2Velocity:
+    elif isinstance(se2_velocity_in_b, SE2Velocity):
         se2_velocity_in_b_vector = se2_velocity_in_b.to_vector()
     else:
         return None
@@ -1126,9 +1136,9 @@ def transform_se3velocity(a_adjoint_b_matrix, se3_velocity_in_b):
     Returns:
         math_helpers.SE3Velocity described in frame a. None if the input velocity is an unknown type.
     """
-    if type(se3_velocity_in_b) == geometry_pb2.SE3Velocity:
+    if isinstance(se3_velocity_in_b, geometry_pb2.SE3Velocity):
         se3_velocity_in_b_vec = (SE3Velocity.from_proto(se3_velocity_in_b)).to_vector()
-    elif type(se3_velocity_in_b) == SE3Velocity:
+    elif isinstance(se3_velocity_in_b, SE3Velocity):
         se3_velocity_in_b_vec = se3_velocity_in_b.to_vector()
     else:
         return None

bosdyn/client/metrics_logging.py

@@ -0,0 +1,147 @@
+# 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).
+
+"""Clients for the metrics logging service."""
+import collections
+import threading
+
+from google.protobuf.duration_pb2 import Duration
+from google.protobuf.timestamp_pb2 import Timestamp
+
+from bosdyn.api.metrics_logging import (absolute_metrics_pb2, metrics_logging_robot_pb2,
+                                        metrics_logging_robot_service_pb2_grpc)
+from bosdyn.client.common import (BaseClient, common_header_errors, error_factory,
+                                  handle_common_header_errors, handle_unset_status_error)
+from bosdyn.client.data_buffer import make_parameter
+from bosdyn.client.exceptions import ResponseError
+
+
+class MissingKeysError(ResponseError):
+    """Metrics requested from the metrics service did not exist."""
+
+
+class UnableToOptOutError(ResponseError):
+    """Unable to opt-out of metrics logging due to invalid license permissions."""
+
+
+class MetricsLoggingClient(BaseClient):
+    """A client for the metrics logging service on the robot.
+    """
+    default_service_name = 'metrics-logging'
+    service_type = 'bosdyn.api.metrics_logging.MetricsLoggingRobotService'
+
+    def __init__(self):
+        super(MetricsLoggingClient,
+              self).__init__(metrics_logging_robot_service_pb2_grpc.MetricsLoggingRobotServiceStub)
+
+    def get_metrics(self, keys=None, include_events=False, **kwargs):
+        """Get metrics from the robot.
+
+        Args:
+            keys(List[strings]): A list of strings representing the keys for metrics that should be returned.
+            include_events(bool): Whether events should be included in the response.
+
+        Returns:
+            The GetMetricsResponse response.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        req = self._get_metrics_request(keys, include_events)
+        return self.call(self._stub.GetMetrics, req, None, _get_metrics_error_from_response,
+                         copy_request=False, **kwargs)
+
+    def get_metrics_async(self, keys=None, include_events=False, **kwargs):
+        """Async version of get_metrics()."""
+        req = self._get_metrics_request(keys, include_events)
+        return self.call_async(self._stub.GetMetrics, req, None, _get_metrics_error_from_response,
+                               copy_request=False, **kwargs)
+
+
+    def get_store_sequence_range(self, **kwargs):
+        """Determine the range of sequence numbers currently being used by the metrics system's store.
+
+        Returns:
+            A list where the first number represents the starting index (inclusive), and the second number represents
+            the final index (inclusive) for the entries in the metrics store.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        req = metrics_logging_robot_pb2.GetStoreSequenceRangeRequest()
+        return self.call(self._stub.GetStoreSequenceRange, req,
+                         self._store_sequence_range_from_response, common_header_errors,
+                         copy_request=False, **kwargs)
+
+    def get_store_sequence_range_async(self, **kwargs):
+        """Async version of get_store_sequence_range()."""
+        req = metrics_logging_robot_pb2.GetStoreSequenceRangeRequest()
+        return self.call_async(self._stub.GetStoreSequenceRange, req,
+                               self._store_sequence_range_from_response, common_header_errors,
+                               copy_request=False, **kwargs)
+
+    def get_absolute_metric_snapshot(self, sequence_numbers, **kwargs):
+        """Get absolute metric snapshots for specific sequence numbers' entries.
+
+        Args:
+            sequence_numbers(List(int)): The list of sequence numbers whose entries should be returned as
+                                         absolute metric snapshots.
+
+        Returns:
+            A list of signed_proto_pb2.SignedProto(). Each signed proto will contain the serialized
+            absolute_metric_pb2.AbsoluteMetricsSnapshot() for the requested sequence number's timestamp.
+            The robot will exclude snapshots if the sequence number does not exist, or the response will exceed
+            the grpc limit.
+
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        req = metrics_logging_robot_pb2.GetAbsoluteMetricSnapshotRequest(
+            sequence_numbers=sequence_numbers)
+        return self.call(self._stub.GetAbsoluteMetricSnapshot, req,
+                         self._get_absolute_metric_snapshots_from_response, common_header_errors,
+                         copy_request=False, **kwargs)
+
+    def get_absolute_metric_snapshot_async(self, sequence_numbers, **kwargs):
+        """Async version of get_absolute_metric_snapshot()."""
+        req = metrics_logging_robot_pb2.GetAbsoluteMetricSnapshotRequest(
+            sequence_numbers=sequence_numbers)
+        return self.call_async(self._stub.GetAbsoluteMetricSnapshot, req,
+                               self._get_absolute_metric_snapshots_from_response,
+                               common_header_errors, copy_request=False, **kwargs)
+
+
+    @staticmethod
+    def _get_metrics_request(keys, include_events):
+        return metrics_logging_robot_pb2.GetMetricsRequest(keys=keys, include_events=include_events)
+
+    @staticmethod
+    def _store_sequence_range_from_response(response):
+        return [response.first_sequence_number, response.last_sequence_number]
+
+    @staticmethod
+    def _get_absolute_metric_snapshots_from_response(response):
+        return response.snapshots
+
+
+def make_parameter_update(label, value, is_incremental, units="", notes=""):
+    """Create a parameter update proto from the label, param value, and if it is incremental."""
+    param_update = absolute_metrics_pb2.ParameterUpdate(incremental=is_incremental)
+    param = make_parameter(label, value, units, notes)
+    if param is not None:
+        param_update.parameter.CopyFrom(param)
+    return param_update
+
+
+@handle_common_header_errors
+def _get_metrics_error_from_response(response):
+    """Return an exception based on response from GetMetrics RPC, None if no error."""
+    # This could return a MissingKeysError for invalid keys, but at the time of writing
+    # this would cause it to throw errors on unreported metrics (not just invalid).
+    # Eg, this consistently would throw errors on a new robot with no metrics reported yet.
+    return None
+
+

bosdyn/client/network_compute_bridge_client.py

@@ -28,6 +28,10 @@ class NetworkComputeRotationError(ResponseError):
     """The robot failed to rotate the image as requested."""
 
 
+class NetworkComputeAnalysisFailedError(ResponseError):
+    """The model failed to analyze the set of input images, but a retry might work."""
+
+
 class NetworkComputeBridgeClient(BaseClient):
     """Client to either the NetworkComputeBridgeService or the NetworkComputeBridgeWorkerService."""
 
@@ -143,6 +147,8 @@ _NETWORK_COMPUTE_STATUS_TO_ERROR.update({
         error_pair(ExternalServerError),
     network_compute_bridge_pb2.NETWORK_COMPUTE_STATUS_ROTATION_ERROR:
         error_pair(NetworkComputeRotationError),
+    network_compute_bridge_pb2.NETWORK_COMPUTE_STATUS_ANALYSIS_FAILED:
+        error_pair(NetworkComputeAnalysisFailedError),
 })