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

bosdyn/client/channel.py

@@ -5,7 +5,6 @@
 # Development Kit License (20191101-BDSDK-SL).
 
 import logging
-import warnings
 
 import grpc
 
@@ -25,6 +24,9 @@ _LOGGER = logging.getLogger(__name__)
 # creating channels in the bosdyn.client.Robot class.
 DEFAULT_MAX_MESSAGE_LENGTH = 100 * (1024**2)
 
+# Useful for clients to ensure there is enough room left in a message for other fields like headers
+DEFAULT_HEADER_BUFFER_LENGTH = 4 * (1024**2)
+
 # Period in milliseconds after which a keepalive ping is sent on the transport.
 DEFAULT_KEEP_ALIVE_TIME_MS = 5000
 

bosdyn/client/command_line.py

@@ -13,16 +13,19 @@ import argparse
 import datetime
 import os
 import signal
+import socket
 import sys
 import threading
 import time
 
+from deprecated.sphinx import deprecated
 from google.protobuf import json_format
 
 import bosdyn.client
 from bosdyn.api import data_acquisition_pb2, image_pb2
 from bosdyn.api.data_buffer_pb2 import Event, TextMessage
 from bosdyn.api.data_index_pb2 import EventsCommentsSpec
+from bosdyn.api.keepalive import keepalive_pb2
 from bosdyn.api.robot_state_pb2 import BehaviorFault
 from bosdyn.util import duration_str, timestamp_to_datetime
 
@@ -38,6 +41,7 @@ from .estop import EstopClient, EstopEndpoint, EstopKeepAlive
 from .exceptions import Error, InvalidRequestError, ProxyConnectionError
 from .image import (ImageClient, ImageResponseError, UnknownImageSourceError, build_image_request,
                     save_images_as_files)
+from .keepalive import KeepaliveClient
 from .lease import LeaseClient
 from .license import LicenseClient
 from .local_grid import LocalGridClient
@@ -1704,6 +1708,81 @@ class LeaseListCommand(Command):
         return str(resource)
 
 
+class EstopCommands(Subcommands):
+    """Commands for interacting with robot estop service."""
+
+    NAME = 'estop'
+
+    def __init__(self, subparsers, command_dict):
+        """Commands for interacting with robot estop service.
+
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(EstopCommands,
+              self).__init__(subparsers, command_dict,
+                             [BecomeEstopCommand, GetEstopConfigCommand, GetEstopStatusCommand])
+
+
+class GetEstopConfigCommand(Command):
+    """Get estop config of estop service."""
+
+    NAME = 'config'
+
+    def __init__(self, subparsers, command_dict):
+        """Call EstopService GetEstopConfig RPC.
+
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(GetEstopConfigCommand, self).__init__(subparsers, command_dict)
+
+    def _run(self, robot, options):
+        """Implementation of the command.
+
+        Args:
+            robot: Robot object on which to run the command.
+            options: Parsed command-line arguments.
+
+        Returns:
+            True.
+        """
+        client = robot.ensure_client(EstopClient.default_service_name)
+        config = client.get_config()
+        print(config)
+
+
+class GetEstopStatusCommand(Command):
+    """Get estop status of estop service."""
+
+    NAME = 'status'
+
+    def __init__(self, subparsers, command_dict):
+        """Call EstopService GetEstopSystemStatus RPC.
+
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(GetEstopStatusCommand, self).__init__(subparsers, command_dict)
+
+    def _run(self, robot, options):
+        """Implementation of the command.
+
+        Args:
+            robot: Robot object on which to run the command.
+            options: Parsed command-line arguments.
+
+        Returns:
+            True.
+        """
+        client = robot.ensure_client(EstopClient.default_service_name)
+        status = client.get_status()
+        print(status)
+
+
 class BecomeEstopCommand(Command):
     """Grab and hold estop until Ctl-C."""
 
@@ -1754,7 +1833,7 @@ class BecomeEstopCommand(Command):
         # Create the endpoint to the robot estop system.
         # Timeout should be chosen to balance safety considerations with expected service latency.
         # See the estop documentation for details.
-        endpoint = EstopEndpoint(client, 'command-line', options.timeout)
+        endpoint = EstopEndpoint(client, f"command-line-{socket.gethostname()}", options.timeout)
         # Have this endpoint to set up the robot's estop system such that it is the sole estop.
         # See the function's docstring and the estop documentation for details.
         endpoint.force_simple_setup()
@@ -1788,6 +1867,14 @@ class BecomeEstopCommand(Command):
         return True
 
 
+class OldBecomeEstopCommand(BecomeEstopCommand):
+    """Old version of BecomeEstopCommand."""
+
+    def run(self, robot, options):
+        print('DEPRECATION WARNING: This command is now "bosdyn.client estop become-estop"')
+        return BecomeEstopCommand.run(self, robot, options)
+
+
 class ImageCommands(Subcommands):
     """Commands for querying images."""
 
@@ -2276,6 +2363,175 @@ class PowerCommand(Subcommands):
             ])
 
 
+class KeepaliveCommand(Subcommands):
+    """Send keepalive commands to the robot."""
+
+    NAME = 'keepalive'
+
+    def __init__(self, subparsers, command_dict):
+        """Send keepalive commands to the robot.
+
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(KeepaliveCommand, self).__init__(subparsers, command_dict, [
+            KeepaliveGetStatusCommand,
+            KeepaliveRemovePoliciesCommand,
+        ])
+
+
+def lease_details(leases):
+    """Returns list of <resource_name>:<sequence>, ...N."""
+    lease_strings = []
+    for lease in leases:
+        sequence_string = ", ".join([str(lease_seq) for lease_seq in lease.sequence])
+        lease_strings.append(f"{lease.resource}:[{sequence_string}]")
+    return ", ".join(lease_strings)
+
+
+class KeepaliveGetStatusCommand(Command):
+    """Get status of keepalive service."""
+
+    NAME = 'status'
+
+    def __init__(self, subparsers, command_dict):
+        """Call KeepaliveService GetStatus RPC.
+
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(KeepaliveGetStatusCommand, self).__init__(subparsers, command_dict)
+        self._parser.add_argument('-f', '--full', action='store_true', default=False,
+                                  help='Show full GetStatus proto as json.')
+
+    def _run(self, robot, options):
+        """Implementation of the command.
+
+        Args:
+            robot: Robot object on which to run the command.
+            options: Parsed command-line arguments.
+
+        Returns:
+            True.
+        """
+        client = robot.ensure_client(KeepaliveClient.default_service_name)
+        status = client.get_status()
+
+        # Give the option to print out the full message.
+        if options.full:
+            print(json_format.MessageToJson(status))
+            return True
+
+        # If there are no policies, there probably isn't anything interesting here.
+        if len(status.status) == 0:
+            print("No active policies")
+            return True
+
+        # List all live policies in a concise message.
+        if len(status.status) == 1:
+            print("Robot returned 1 live policy:")
+        else:
+            print(f"Robot returned {len(status.status)} live policies:")
+        for live_policy in status.status:
+            rough_robot_timestamp = status.header.response_timestamp.ToSeconds()
+            last_checkin = live_policy.last_checkin.ToSeconds()
+            time_elapsed = rough_robot_timestamp - last_checkin
+            # Go through each action, and create a helpful message describing the status.
+            action_list = []
+            for action in live_policy.policy.actions:
+                name = action.WhichOneof("action")
+                # If this is a lease_stale or auto_return action, include some lease info.
+                name_maybe_with_details = name
+                if action.HasField("lease_stale"):
+                    name_maybe_with_details = f"{name_maybe_with_details} ({lease_details(action.lease_stale.leases)})"
+                if action.HasField("auto_return"):
+                    name_maybe_with_details = f"{name_maybe_with_details} ({lease_details(action.auto_return.leases)})"
+                # Add an indicator if the policy action is active or not.
+                action_after_time = action.after.ToSeconds()
+                active_message = "NOT active"
+                if time_elapsed > action.after.ToSeconds():
+                    active_message = "ACTIVE"
+                action_list.append(
+                    f"{name_maybe_with_details} after {action_after_time} seconds, {active_message}"
+                )
+            formatted_string = f"id: {live_policy.policy_id}\n client_name: {live_policy.client_name}\n last checkin {time_elapsed}s ago"
+            # Only the supervisor policy seems to have a name.
+            if live_policy.policy.name:
+                formatted_string = formatted_string + f"\n policy name: '{live_policy.policy.name}'"
+            if live_policy.policy.user_id:
+                formatted_string = formatted_string + f"\n user_id: '{live_policy.policy.user_id}'"
+            if len(live_policy.policy.associated_leases) > 0:
+                formatted_string = formatted_string + f"\n associated_leases: {lease_details(live_policy.policy.associated_leases)}"
+            print(formatted_string)
+            print(" actions:")
+            for index, action in enumerate(action_list):
+                print(f"   {action}")
+            print("")
+
+        # If there is an action control action, we should indicate that.
+        if len(status.active_control_actions) == 0:
+            return True
+        for action in status.active_control_actions:
+            enum_name = keepalive_pb2.GetStatusResponse.PolicyControlAction.Name(action)
+            print(f"Active control action: {enum_name}")
+        return True
+
+
+class KeepaliveRemovePoliciesCommand(Command):
+    """Remove keepalive policies."""
+
+    NAME = 'remove'
+
+    def __init__(self, subparsers, command_dict):
+        """Remove keepalive policies.
+
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(KeepaliveRemovePoliciesCommand, self).__init__(subparsers, command_dict)
+        self._parser.add_argument('--policy-id', type=int, nargs='+',
+                                  help='Specify specific policy ids to remove.')
+
+    def _run(self, robot, options):
+        """Implementation of the command.
+
+        Args:
+            robot: Robot object on which to run the command.
+            options: Parsed command-line arguments.
+
+        Returns:
+            True.
+        """
+        client = robot.ensure_client(KeepaliveClient.default_service_name)
+        current_policies = client.get_status().status
+        current_policy_ids = [s.policy_id for s in current_policies]
+
+        # If there are no policies, there probably isn't anything interesting here.
+        if len(current_policies) == 0:
+            print("No active policies")
+            return True
+
+        to_rm = []
+        if options.policy_id:
+            # Remove specific policies.
+            for policy_id in options.policy_id:
+                if policy_id in current_policy_ids:
+                    to_rm.append(policy_id)
+                else:
+                    print(f"Policy '{policy_id}' not found.")
+        else:
+            # Remove all current policies.
+            to_rm = current_policy_ids
+
+        client.modify_policy(policy_ids_to_remove=to_rm)
+        print(f"Removed {len(to_rm)} policies")
+
+        return True
+
+
 class PowerRobotCommand(Command):
     """Control the power of the entire robot."""
 
@@ -2405,12 +2661,14 @@ def main(args=None):
     DataServiceCommands(subparsers, command_dict)
     TimeSyncCommand(subparsers, command_dict)
     LeaseCommands(subparsers, command_dict)
-    BecomeEstopCommand(subparsers, command_dict)
+    OldBecomeEstopCommand(subparsers, command_dict)
+    EstopCommands(subparsers, command_dict)
     ImageCommands(subparsers, command_dict)
     LocalGridCommands(subparsers, command_dict)
     DataAcquisitionCommand(subparsers, command_dict)
     HostComputerIPCommand(subparsers, command_dict)
     PowerCommand(subparsers, command_dict)
+    KeepaliveCommand(subparsers, command_dict)
 
     options = parser.parse_args(args=args)
 

bosdyn/client/common.py

@@ -5,10 +5,10 @@
 # Development Kit License (20191101-BDSDK-SL).
 
 """Contains elements common to all service clients."""
+import concurrent
 import copy
 import functools
 import logging
-import math
 import socket
 import types
 
@@ -232,6 +232,37 @@ def handle_custom_params_errors(*args, status_value=None, status_field_name='sta
     return decorator
 
 
+def handle_license_errors(func):
+    """Decorate "error from response" functions to handle typical license errors."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return common_license_errors(*args) or func(*args, **kwargs)
+
+    return wrapper
+
+
+def handle_license_errors_if_present(func):
+    """Decorate "error from response" functions to handle typical license errors.
+    Does not raise an error for STATUS_UNKNOWN.
+    Use for responses that may only sometimes fill out the license status."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return common_license_errors(*args, allow_unset=True) or func(*args, **kwargs)
+
+    return wrapper
+
+
+def common_license_errors(response, allow_unset=False):
+    license_status = response.license_status
+    if allow_unset and license_status == license_pb2.LicenseInfo.STATUS_UNKNOWN:
+        return None
+    elif license_status != license_pb2.LicenseInfo.STATUS_VALID:
+        return LicenseError(response)
+    return None
+
+
 def maybe_raise(exc):
     """raise the provided exception if it is not None"""
     if exc is not None:
@@ -300,6 +331,7 @@ class BaseClient(object):
         self.response_processors = []
         self.lease_wallet = None
         self.client_name = None
+        self.executor = None
 
     @staticmethod
     @deprecated(reason='Forces serialization even if the logging is not happening.  Do not use.',
@@ -331,6 +363,7 @@ class BaseClient(object):
         self.logger = other.logger.getChild(self._name or self._service_type_short)
         self.lease_wallet = other.lease_wallet
         self.client_name = other.client_name
+        self.executor = other.executor
 
     def update_request_iterator(self, request_iterator, logger, rpc_method, is_blocking,
                                 copy_request=True):
@@ -444,7 +477,7 @@ class BaseClient(object):
 
         value_from_response and error_from_response should not raise their own exceptions!
 
-        Asynchronous calls cannot be done with streaming rpcs right now.
+        call_async does not accept streaming rpcs, see 'call_async_streaming'.
         """
         request = self._apply_request_processors(request, copy_request=copy_request)
         logger = self._get_logger(rpc_method)
@@ -468,6 +501,25 @@ class BaseClient(object):
         response_future.add_done_callback(on_finish)
         return FutureWrapper(response_future, value_from_response, error_from_response)
 
+    @process_kwargs
+    def call_async_streaming(self, rpc_method, request, value_from_response=None,
+                             error_from_response=None, assemble_type=None, copy_request=False,
+                             **kwargs):
+        """Returns a Future for rpc_method(request, kwargs) after running processors.
+
+        value_from_response and error_from_response should not raise their own exceptions.
+
+        A version of 'call_async' for streaming rpcs. True async streaming calls are not supported by
+        python grpc. Instead, this call creates a thread that runs the synchronous 'call' function.
+        """
+        request = self._apply_request_processors(request, copy_request=copy_request)
+        if self.executor is None:
+            self.executor = concurrent.futures.ThreadPoolExecutor()
+
+        future = self.executor.submit(self.call, rpc_method, request, assemble_type=assemble_type,
+                                      copy_request=copy_request, **kwargs)
+        return FutureWrapper(future, value_from_response, error_from_response, is_streaming=True)
+
     def _apply_request_processors(self, request, copy_request=True):
         if request is None:
             return
@@ -498,10 +550,11 @@ class BaseClient(object):
 class FutureWrapper():
     """Wraps a Future to aid more complicated clients' async calls."""
 
-    def __init__(self, future, value_from_response, error_from_response):
+    def __init__(self, future, value_from_response, error_from_response, is_streaming=False):
         self.original_future = future
         self._error_from_response = error_from_response
         self._value_from_response = value_from_response
+        self._is_streaming = is_streaming
 
     def __repr__(self):
         return self.original_future.__repr__()
@@ -521,7 +574,7 @@ class FutureWrapper():
     def traceback(self, **kwargs):
         return self.original_future.traceback(**kwargs)
 
-    def add_done_callback(self, cb):
+    def add_done_callback(self, cb, assemble_type=None):
         """Add callback executed on FutureWrapper when future is done."""
         self.original_future.add_done_callback(lambda not_used_original_future: cb(self))
 
@@ -535,7 +588,6 @@ class FutureWrapper():
 
         if self._value_from_response is None:
             return base_result
-
         return self._value_from_response(base_result)
 
     def exception(self, **kwargs):
@@ -547,6 +599,11 @@ class FutureWrapper():
                 return None
             return self._error_from_response(self.original_future.result())
 
+        # 'call_async_streaming' uses the non-async 'call' function. 'call' does all of it's
+        # own error handling so just return any errors from that call as is.
+        if self._is_streaming:
+            return error
+
         return translate_exception(error)
 
 

bosdyn/client/data_acquisition.py

@@ -7,9 +7,6 @@
 """General client implementation for the main, on-robot data-acquisition service."""
 
 import collections
-import functools
-import json
-import time
 
 from google.protobuf import json_format
 

bosdyn/client/data_acquisition_helpers.py

@@ -4,10 +4,7 @@
 # is subject to the terms and conditions of the Boston Dynamics Software
 # Development Kit License (20191101-BDSDK-SL).
 
-import io
-import json
 import logging
-import os
 import ssl
 import time
 from pathlib import Path

bosdyn/client/data_acquisition_plugin_service.py

@@ -42,7 +42,6 @@ However, the data_collect_fn function should update the status to STATUS_SAVING
 storing the data.
 """
 
-import concurrent.futures
 import logging
 import threading
 import time
@@ -242,6 +241,34 @@ class DataAcquisitionStoreHelper(object):
         future = self.store_client.store_data_async(message, data_id, file_extension)
         self.data_id_future_pairs.append((data_id, future))
 
+    def store_data_as_chunks(self, message, data_id, file_extension=None):
+        """Store a data message by streaming with the data acquisition store service.
+
+        Args:
+            message (bytes): Data to store.
+            data_id (bosdyn.api.DataIdentifier) : Data identifier to use for storing this data.
+            file_extension (string) : File extension to use for writing the data to a file.
+
+        Raises:
+            RPCError: Problem communicating with the robot.
+        """
+        future = self.store_client.store_data_as_chunks_async(message, data_id, file_extension)
+        self.data_id_future_pairs.append((data_id, future))
+
+    def store_file(self, file_path, data_id, file_extension=None):
+        """Store a file with the data acquisition store service.
+
+        Args:
+            file_path (string): Path to the file to store.
+            data_id (bosdyn.api.DataIdentifier) : Data identifier to use for storing this file.
+            file_extension (string) : File extension to use for writing the data to the file.
+
+        Raises:
+            RPCError: Problem communicating with the robot.
+        """
+        future = self.store_client.store_file_async(file_path, data_id, file_extension)
+        self.data_id_future_pairs.append((data_id, future))
+
     def cancel_check(self):
         """Raises RequestCancelledError if the request has already been cancelled."""
         self.state.cancel_check()