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

bosdyn/client/command_line.py

@@ -29,12 +29,13 @@ from bosdyn.util import duration_str, timestamp_to_datetime
 from .auth import InvalidLoginError, InvalidTokenError
 from .data_acquisition import DataAcquisitionClient
 from .data_acquisition_helpers import acquire_and_process_request
+from .data_acquisition_plugin import DataAcquisitionPluginClient
 from .data_buffer import DataBufferClient
 from .data_service import DataServiceClient
 from .directory import DirectoryClient, NonexistentServiceError
 from .directory_registration import DirectoryRegistrationClient, DirectoryRegistrationResponseError
 from .estop import EstopClient, EstopEndpoint, EstopKeepAlive
-from .exceptions import Error, InvalidAppTokenError, InvalidRequestError, ProxyConnectionError
+from .exceptions import Error, InvalidRequestError, ProxyConnectionError
 from .image import (ImageClient, ImageResponseError, UnknownImageSourceError, build_image_request,
                     save_images_as_files)
 from .lease import LeaseClient
@@ -92,9 +93,6 @@ class Command(object, metaclass=abc.ABCMeta):
         except ProxyConnectionError:
             print('Could not contact robot with hostname "{}".'.format(options.hostname),
                   file=sys.stderr)
-        except InvalidAppTokenError:
-            print('The provided app token "{}" is invalid.'.format(options.app_token),
-                  file=sys.stderr)
         except InvalidTokenError:
             print('The provided user token is invalid.', file=sys.stderr)
         except InvalidLoginError:
@@ -719,6 +717,7 @@ class GetLogCommand(Command):
 
     def __init__(self, subparsers, command_dict):
         """Get log status from robot
+
         Args:
             subparsers: List of argument parsers.
             command_dict: Dictionary of command names which take parsed options.
@@ -728,9 +727,11 @@ class GetLogCommand(Command):
 
     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
         """
@@ -748,6 +749,7 @@ class GetActiveLogStatusesCommand(Command):
 
     def __init__(self, subparsers, command_dict):
         """Retrieve active log statuses for robot.
+
         Args:
             subparsers: List of argument parsers.
             command_dict: Dictionary of command names which take parsed options.
@@ -756,9 +758,11 @@ class GetActiveLogStatusesCommand(Command):
 
     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
         """
@@ -882,6 +886,7 @@ class StartRetroLogCommand(Command):
 
     def __init__(self, subparsers, command_dict):
         """Start a retro log
+
         Args:
             subparsers: List of argument parsers.
             command_dict: Dictionary of command names which take parsed options.
@@ -891,9 +896,11 @@ class StartRetroLogCommand(Command):
 
     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
         """
@@ -1903,7 +1910,6 @@ class GetImageCommand(Command):
             print('Robot cannot generate the "{}" at this time.  Retry the command.'.format(
                 options.source_name))
             return False
-
         # Save the image files in the correct format (jpeg, pgm for raw/rle).
         save_images_as_files(response)
 
@@ -2027,7 +2033,7 @@ class DataAcquisitionCommand(Subcommands):
         """
         super(DataAcquisitionCommand, self).__init__(subparsers, command_dict, [
             DataAcquisitionServiceCommand, DataAcquisitionRequestCommand,
-            DataAcquisitionStatusCommand
+            DataAcquisitionStatusCommand, DataAcquisitionGetLiveDataCommand
         ])
 
 
@@ -2110,9 +2116,10 @@ class DataAcquisitionServiceCommand(Command):
         # Constants to describe width of columns for printing the data names and types
         self._data_type_width = 15
         self._data_name_width = 35
-        self._service_name_width = 30
+        self._service_name_width = 35
+        self._has_live_data_width = 30
 
-    def _format_and_print_capability(self, data_type, data_name, service_name=""):
+    def _format_and_print_capability(self, data_type, data_name, service_name="", has_live_data=""):
         """Print the data acquisition capability.
 
         Args:
@@ -2120,8 +2127,10 @@ class DataAcquisitionServiceCommand(Command):
             data_name (string): The name of the data acquisition capability
             service_name(string): For image capabilities, a service name is required.
         """
-        print(('{:' + str(self._data_type_width) + '} {:' + str(self._data_name_width) + '} {:' +
-               str(self._service_name_width) + '}').format(data_type, data_name, service_name))
+        print(
+            ('{:' + str(self._data_type_width) + '} {:' + str(self._data_name_width) + '} {:' +
+             str(self._service_name_width) + '} {:' + str(self._has_live_data_width) + '}').format(
+                 data_type, data_name, service_name, has_live_data))
 
     def _run(self, robot, options):
         """Implementation of the 'info' command.
@@ -2133,10 +2142,13 @@ class DataAcquisitionServiceCommand(Command):
         capabilities = robot.ensure_client(
             DataAcquisitionClient.default_service_name).get_service_info()
         print("Data Acquisition Service's Available Capabilities\n")
-        self._format_and_print_capability("Data Type", "Data Name", "(optional) Service Name")
-        print("-" * (self._data_type_width + self._data_name_width + self._service_name_width))
+        self._format_and_print_capability("Data Type", "Data Name", "(optional) Service Name",
+                                          "(optional) has_live_data")
+        print("-" * (self._data_type_width + self._data_name_width + self._service_name_width +
+                     self._has_live_data_width))
         for data_name in capabilities.data_sources:
-            self._format_and_print_capability("data", data_name.name, data_name.service_name)
+            self._format_and_print_capability("data", data_name.name, data_name.service_name,
+                                              str(data_name.has_live_data))
         for img_service in capabilities.image_sources:
             for img in img_service.image_source_names:
                 self._format_and_print_capability("image", img, img_service.service_name)
@@ -2178,6 +2190,41 @@ class DataAcquisitionStatusCommand(Command):
         return True
 
 
+class DataAcquisitionGetLiveDataCommand(Command):
+    """Call GetLiveData based on service name."""
+
+    NAME = 'live'
+
+    def __init__(self, subparsers, command_dict):
+        """Call GetLiveData based on service name.
+
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(DataAcquisitionGetLiveDataCommand, self).__init__(subparsers, command_dict)
+        self._parser.add_argument('--data-source', metavar='DATA_SRC', default=[],
+                                  help='Data source name', action='append', required=True)
+
+    def _run(self, robot, options):
+        """Implementation of the 'live' command.
+
+        Args:
+            robot: Robot object on which to run the command.
+            options: Parsed command-line arguments.
+
+        Returns:
+            True once complete.
+        """
+        daq_client = robot.ensure_client(DataAcquisitionClient.default_service_name)
+        request = data_acquisition_pb2.LiveDataRequest()
+        request.data_captures.extend(
+            [data_acquisition_pb2.DataCapture(name=data_name) for data_name in options.data_source])
+        response = daq_client.get_live_data(request)
+        print(response)
+        return True
+
+
 class HostComputerIPCommand(Command):
     """Determine a computer's IP address."""
 
@@ -2248,6 +2295,7 @@ class PowerRobotCommand(Command):
 
     def _run(self, robot, options):
         """
+
         Args:
             robot: Robot object on which to run the command.
             options: Parsed command-line arguments.
@@ -2282,6 +2330,7 @@ class PowerPayloadsCommand(Command):
 
     def _run(self, robot, options):
         """
+
         Args:
             robot: Robot object on which to run the command.
             options: Parsed command-line arguments.
@@ -2317,6 +2366,7 @@ class PowerWifiRadioCommand(Command):
 
     def _run(self, robot, options):
         """
+
         Args:
             robot: Robot object on which to run the command.
             options: Parsed command-line arguments.
@@ -2368,6 +2418,7 @@ def main(args=None):
 
     # Create robot object and authenticate.
     sdk = bosdyn.client.create_standard_sdk('BosdynClient')
+    sdk.register_service_client(DataAcquisitionPluginClient)
 
     robot = sdk.create_robot(options.hostname)
 

bosdyn/client/common.py

@@ -16,6 +16,7 @@ import grpc
 from deprecated.sphinx import deprecated
 
 from bosdyn.api.header_pb2 import CommonError
+from bosdyn.deprecated import moved_to
 
 from .channel import TransportError, translate_exception
 from .data_chunk import chunk_message, parse_from_chunks
@@ -98,7 +99,7 @@ def custom_params_error(response, status_value=None, status_field_name='status',
 
 def error_pair(error_message):
     """Creates a pair of an error class and the associated docstring as the error message
-       which can be used by the error_factory.
+    which can be used by the error_factory.
 
     Args:
         error_message: A class that inherits from the python Error class.
@@ -486,13 +487,12 @@ class BaseClient(object):
     def _get_logger(self, rpc_method):
         method_name = getattr(rpc_method, '_method', None)
         if method_name:
-            method_name_short = str(method_name).split(BaseClient._SPLIT_METHOD)[-1]
+            method_name_short = str(method_name.decode()).rsplit(BaseClient._SPLIT_METHOD, 1)[-1]
             # This returns the same instance if it's been created before.
             return self.logger.getChild(method_name_short)
         return self.logger
 
-    chunk_message = deprecated(reason='Use bosdyn.client.data_chunk.chunk_message() instead.',
-                               version='3.3.0')(chunk_message)
+    chunk_message = moved_to(chunk_message, version='3.3.0')
 
 
 class FutureWrapper():

bosdyn/client/data_acquisition.py

@@ -15,10 +15,11 @@ from google.protobuf import json_format
 
 from bosdyn.api import data_acquisition_pb2 as data_acquisition
 from bosdyn.api import data_acquisition_service_pb2_grpc as data_acquisition_service
-from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,
-                                  handle_common_header_errors, handle_unset_status_error)
-from bosdyn.client.exceptions import Error, ResponseError
-from bosdyn.util import now_timestamp, seconds_to_duration
+from bosdyn.client.common import (BaseClient, common_header_errors, custom_params_error,
+                                  error_factory, error_pair, handle_common_header_errors,
+                                  handle_custom_params_errors, handle_unset_status_error)
+from bosdyn.client.exceptions import Error, InternalServerError, ResponseError
+from bosdyn.util import now_nsec, now_sec, now_timestamp, seconds_to_duration
 
 
 class DataAcquisitionResponseError(ResponseError):
@@ -64,8 +65,7 @@ class DataAcquisitionClient(BaseClient):
             if not self._timesync_endpoint:
                 data_timestamp = now_timestamp()
             else:
-                data_timestamp = self._timesync_endpoint.robot_timestamp_from_local_secs(
-                    time.time())
+                data_timestamp = self._timesync_endpoint.robot_timestamp_from_local_secs(now_sec())
         action_id = data_acquisition.CaptureActionId(action_name=action_name, group_name=group_name,
                                                      timestamp=data_timestamp)
         req = data_acquisition.AcquireDataRequest(acquisition_requests=acquisition_requests,
@@ -174,6 +174,7 @@ class DataAcquisitionClient(BaseClient):
 
     def cancel_acquisition(self, request_id, **kwargs):
         """Cancel a data acquisition based on the request id.
+
         Args:
           request_id (int): The request id associated with an AcquireData request.
         Raises:
@@ -197,6 +198,16 @@ class DataAcquisitionClient(BaseClient):
                                error_from_response=_cancel_acquisition_error, copy_request=False,
                                **kwargs)
 
+    def get_live_data(self, request):
+        """Call the GetLiveData RPC of the plugin service."""
+        return self.call(self._stub.GetLiveData, request, error_from_response=_get_live_data_error,
+                         copy_request=True)
+
+    def get_live_data_async(self, request):
+        """Async version of the get_live_data() RPC."""
+        return self.call_async(self._stub.GetLiveData, request,
+                               error_from_response=_get_live_data_error, copy_request=True)
+
 
 _ACQUIRE_DATA_STATUS_TO_ERROR = collections.defaultdict(lambda:
                                                         (DataAcquisitionResponseError, None))
@@ -221,6 +232,17 @@ _CANCEL_ACQUISITION_STATUS_TO_ERROR.update({
         error_pair(CancellationFailedError)
 })
 
+_CAPABILITY_LIVE_DATA_STATUS_TO_ERROR = collections.defaultdict(lambda: (None, None))
+_CAPABILITY_LIVE_DATA_STATUS_TO_ERROR.update({
+    # STATUS_UNKNOWN is not handled directly.
+    data_acquisition.LiveDataResponse.CapabilityLiveData.STATUS_OK: (None, None),
+    data_acquisition.LiveDataResponse.CapabilityLiveData.STATUS_UNKNOWN_CAPTURE_TYPE:
+        error_pair(UnknownCaptureTypeError),
+    # STATUS_CUSTOM_PARAMS_ERROR is handled separately.
+    data_acquisition.LiveDataResponse.CapabilityLiveData.STATUS_INTERNAL_ERROR:
+        error_pair(InternalServerError),
+})
+
 
 def metadata_to_proto(metadata):
     """Checks the type to determine if a conversion is required to create a
@@ -278,6 +300,25 @@ def _cancel_acquisition_error(response):
                          status_to_error=_CANCEL_ACQUISITION_STATUS_TO_ERROR)
 
 
+@handle_common_header_errors
+def _get_live_data_error(response):
+    """Return a custom exception based on the first invalid CapabilityLiveData, None if no error."""
+    for capability_live_data in response.live_data:
+        result = custom_params_error(capability_live_data, total_response=response)
+        if result is not None:
+            return result
+
+        result = error_factory(
+            response, capability_live_data.status,
+            status_to_string=data_acquisition.LiveDataResponse.CapabilityLiveData.Status.Name,
+            status_to_error=_CAPABILITY_LIVE_DATA_STATUS_TO_ERROR)
+        if result is not None:
+            # The exception is using the capability_live_data. Replace it with the full response.
+            result.response = response
+            return result
+    return None
+
+
 def _get_service_info_capabilities(response):
     return response.capabilities
 

bosdyn/client/data_acquisition_plugin.py

@@ -14,8 +14,8 @@ from bosdyn.client.common import (BaseClient, error_factory, error_pair,
                                   handle_common_header_errors, handle_custom_params_errors,
                                   handle_unset_status_error)
 from bosdyn.client.data_acquisition import (DataAcquisitionClient, DataAcquisitionResponseError,
-                                            UnknownCaptureTypeError, acquire_data_error,
-                                            get_request_id, metadata_to_proto)
+                                            UnknownCaptureTypeError, _get_live_data_error,
+                                            acquire_data_error, get_request_id, metadata_to_proto)
 from bosdyn.util import now_timestamp
 
 
@@ -78,6 +78,16 @@ class DataAcquisitionPluginClient(BaseClient):
         return self.call_async(self._stub.AcquirePluginData, request,
                                error_from_response=acquire_data_error, copy_request=False, **kwargs)
 
+    def get_live_data(self, request):
+        """Call the GetLiveData RPC of the plugin service."""
+        return self.call(self._stub.GetLiveData, request, error_from_response=_get_live_data_error,
+                         copy_request=True)
+
+    def get_live_data_async(self, request):
+        """Async version of the get_live_data() RPC."""
+        return self.call_async(self._stub.GetLiveData, request,
+                               error_from_response=_get_live_data_error, copy_request=True)
+
     # The get_status, get_service_info, and cancel_acquisition methods are identical to the ones
     # implemented in the DataAcquisitionClient.
     if sys.version_info.major == 2:

bosdyn/client/data_acquisition_plugin_service.py

@@ -286,6 +286,8 @@ class DataAcquisitionPluginService(
             the data collection function or saving any data. Ordered input arguments (to acquire_response_fn):
             data_acquisition_pb2.AcquirePluginDataRequest, data_acquisition_pb2.AcquirePluginDataResponse. Output (to
             data_collect_fn): Boolean
+        live_response_fn: Optional function that sends signals data to the robot for purposes of displaying it on the tablet and Orbit during teleoperation. Input argument (to live_response_fn):
+            data_acquisition_pb2.LiveDataRequest.
         executor: Optional thread pool.
 
     Attributes:
@@ -294,6 +296,7 @@ class DataAcquisitionPluginService(
             this plugin can do.
         data_collect_fn: Function that performs the data collection and storage.
         acquire_response_fn: Function that can validate a request and provide a timeout deadline.
+        live_response_fn: Function that sends signals data to the robot for purposes of displaying it on the tablet and Orbit during teleoperation.
         request_manager (RequestManager): Helper class which manages the RequestStates created with
             each acquisition RPC.
         executor (ThreadPoolExecutor): Thread pool to run the plugin service on.
@@ -303,7 +306,7 @@ class DataAcquisitionPluginService(
     service_type = 'bosdyn.api.DataAcquisitionPluginService'
 
     def __init__(self, robot, capabilities, data_collect_fn, acquire_response_fn=None,
-                 executor=None, logger=None):
+                 executor=None, logger=None, live_response_fn=None):
         super(DataAcquisitionPluginService, self).__init__()
         self.logger = logger or _LOGGER
         self.capabilities = capabilities
@@ -313,6 +316,7 @@ class DataAcquisitionPluginService(
         }
         self.data_collect_fn = data_collect_fn
         self.acquire_response_fn = acquire_response_fn
+        self.live_response_fn = live_response_fn
         self.request_manager = RequestManager()
         self.executor = executor or ThreadPoolExecutor(max_workers=2)
         self.robot = robot
@@ -320,7 +324,7 @@ class DataAcquisitionPluginService(
         self.data_buffer_client = robot.ensure_client(DataBufferClient.default_service_name)
 
     def validate_params(self, request, response):
-        """Validate that any parameters set in the request are valid according the the spec."""
+        """Validate that any parameters set in the request are valid according the spec."""
         for capture in request.acquisition_requests.data_captures:
             try:
                 error = self.value_validators[capture.name](capture.custom_params)
@@ -468,6 +472,33 @@ class DataAcquisitionPluginService(
             populate_response_header(response, request)
         return response
 
+    def GetLiveData(self, request, context):
+        """Get the live data available from this plugin.
+
+        Args:
+            request (data_acquisition_pb2.LiveDataRequest): The live data request with params.
+            context (GRPC ClientContext): tracks internal grpc statuses and information (unused).
+        Returns:
+            response (data_acquisition_pb2.LiveDataResponse): Result of live_response_fn.
+        """
+        response = data_acquisition_pb2.LiveDataResponse()
+        with ResponseContext(response, request, self.data_buffer_client):
+            try:
+                if self.live_response_fn is not None:
+                    response = self.live_response_fn(request)
+                    populate_response_header(response, request)
+                else:
+                    populate_response_header(
+                        response, request,
+                        error_code=header_pb2.CommonError.CODE_INTERNAL_SERVER_ERROR,
+                        error_msg="live_response_fn is None")
+            except Exception as general_error:  # pylint: disable=broad-exception-caught
+                self.logger.exception("Failed during call to user live response function")
+                populate_response_header(
+                    response, request, error_code=header_pb2.CommonError.CODE_INTERNAL_SERVER_ERROR,
+                    error_msg=str(general_error))
+        return response
+
 
 # pylint: disable=protected-access
 class RequestManager:

bosdyn/client/data_acquisition_store.py

@@ -255,6 +255,40 @@ class DataAcquisitionStoreClient(BaseClient):
                                error_from_response=common_header_errors, copy_request=False,
                                **kwargs)
 
+    def query_stored_captures(self, query=None, **kwargs):
+        """Query stored captures from the robot.
+
+        Args:
+            query (bosdyn.api.DataQueryParams) : Query parameters.
+        Raises:
+            RpcError: Problem communicating with the robot.
+        """
+        request = data_acquisition_store.QueryStoredCapturesRequest(query=query)
+        self._apply_request_processors(request, copy_request=False)
+        return self.call(self._stub.QueryStoredCaptures, request,
+                         error_from_response=common_header_errors,
+                         assemble_type=data_acquisition_store.QueryStoredCapturesResponse,
+                         copy_request=False, **kwargs)
+
+    def query_max_capture_id(self, **kwargs):
+        """Query max capture id from the robot.
+        Returns:
+            QueryMaxCaptureIdResult, which has a max_capture_id uint64, corresponding to the 
+            greatest capture id on the robot.  Used for skiping DAQ synchronization
+            on connect.
+        """
+        request = data_acquisition_store.QueryMaxCaptureIdRequest()
+        return self.call(self._stub.QueryMaxCaptureId, request,
+                         value_from_response=_get_max_capture_id,
+                         error_from_response=common_header_errors, copy_request=False, **kwargs)
+
+    def query_max_capture_id_async(self, **kwargs):
+        """Async version of the query_max_capture_id() RPC."""
+        request = data_acquisition_store.QueryMaxCaptureIdRequest(query=query)
+        return self.call_async(self._stub.QueryMaxCaptureId, request,
+                               value_from_response=_get_max_capture_id,
+                               error_from_response=common_header_errors, copy_request=False,
+                               **kwargs)
 
 
 def _get_action_ids(response):
@@ -271,3 +305,7 @@ def _get_image(response):
 
 def _get_metadata(response):
     return response.metadata
+
+
+def _get_max_capture_id(response):
+    return response.max_capture_id

bosdyn/client/data_buffer.py

@@ -143,10 +143,7 @@ class DataBufferClient(BaseClient):
     def _do_add_text_messages(self, func, text_messages, **kwargs):
         """Internal text message RPC stub call."""
         request = data_buffer_protos.RecordTextMessagesRequest()
-        for in_text_msg in text_messages:
-            # pylint: disable=no-member
-            request.text_messages.add().CopyFrom(in_text_msg)
-
+        request.text_messages.extend(text_messages)
         return func(self._stub.RecordTextMessages, request, value_from_response=None,
                     error_from_response=common_header_errors, **kwargs)
 
@@ -364,7 +361,7 @@ class DataBufferClient(BaseClient):
 
 
 class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attributes
-    """A logging system Handler that will publish text to a the data-buffer service.
+    """A logging system Handler that will publish text to the data-buffer service.
 
     Args:
         service: Name of the service. See LogAnnotationTextMessage.
@@ -375,6 +372,7 @@ class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attr
         msg_num_limit: If number of messages reaches this number, send data with data_buffer_client.
         msg_age_limit: If messages have been sitting locally for this many seconds, send data with
                        data_buffer_client.
+        skip_rpcs: Do not log any messages for RPC sending.
 
     Raises:
         log_annotation.InvalidArgument: The TimeSyncEndpoint is not valid.
@@ -382,8 +380,11 @@ class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attr
 
     def __init__(  # pylint: disable=too-many-arguments
             self, service, data_buffer_client, level=logging.NOTSET, time_sync_endpoint=None,
-            rpc_timeout=1, msg_num_limit=10, msg_age_limit=1):
+            rpc_timeout=1, msg_num_limit=10, msg_age_limit=1, skip_rpcs=False):
         logging.Handler.__init__(self, level=level)
+        self.addFilter(is_not_text_log)
+        if skip_rpcs:
+            self.addFilter(is_not_rpc)
         self.msg_age_limit = msg_age_limit
         self.msg_num_limit = msg_num_limit
         self.rpc_timeout = rpc_timeout
@@ -544,11 +545,12 @@ class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attr
                         if len(self._msg_queue) >= self._dump_msg_count:
                             self._dump_msg_queue()
 
-    def record_to_msg(self, record):
+    def record_to_msg(self, record: logging.LogRecord):
         """Convert logging record to TextMessage proto."""
         level = self.record_level_to_proto_level(record.levelno)
         msg = data_buffer_protos.TextMessage(source=self.service, level=level,
-                                             message=self.format(record))
+                                             message=self.format(record), filename=record.filename,
+                                             line_number=record.lineno)
         # pylint: disable=no-member
         if self.time_sync_endpoint is not None:
             try:
@@ -572,3 +574,15 @@ class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attr
         if record_level >= logging.INFO:
             return data_buffer_protos.TextMessage.LEVEL_INFO
         return data_buffer_protos.TextMessage.LEVEL_DEBUG
+
+
+def is_not_text_log(record: logging.LogRecord) -> bool:
+    """Filter out the RecordMessages calls that the handler sends so that we do not go into an infinite loop."""
+    return not record.name.endswith('.DataBufferService.RecordTextMessages')
+
+
+def is_not_rpc(record: logging.LogRecord) -> bool:
+    """Because our loggers use the form sdk_name.robot_name.service_name.rpc_method, we can't easily just turn
+    off all logging for rpcs.  This function identifies the rpc logging calls to be able to strip them out."""
+    return not (record.module == 'common' and
+                (record.funcName == 'call' or record.funcName == 'call_async'))

bosdyn/client/data_chunk.py

@@ -27,6 +27,7 @@ def chunk_serialized(serialized: bytes, data_chunk_byte_size: int):
 
 def chunk_message(message, data_chunk_byte_size: int):
     """Take a message, and split it into data chunks
+
     Args:
         data_chunk_byte_size: max size of each streamed message
     """

bosdyn/client/directory_registration.py

@@ -55,7 +55,6 @@ class DirectoryRegistrationClient(BaseClient):
             host_ip,
             port,
             user_token_required=True,
-            application_token_required=False,
             liveness_timeout_secs=0,
             **kwargs):
         """Register a service routing with the robot.
@@ -72,7 +71,6 @@ class DirectoryRegistrationClient(BaseClient):
           host_ip: The ip address of the system that the service is being hosted on.
           port: The port number the service can be accessed through on the host system.
           user_token_required: If a user token should be verified to access the service.
-          application_token_required: Deprecated - Do not use.
           liveness_timeout_secs: Number of seconds without directory heartbeat before timeout fault.
 
         Raises:
@@ -80,11 +78,6 @@ class DirectoryRegistrationClient(BaseClient):
           ServiceAlreadyExistsError: The service already exists.
           DirectoryRegistrationResponseError: Something went wrong during the directory registration.
         """
-        if (application_token_required):
-            _LOGGER.warning(
-                'The application_token_required parameter has been deprecated and will have no effect.'
-            )
-
         service_entry = directory_pb2.ServiceEntry(
             name=name,
             type=service_type,
@@ -125,7 +118,6 @@ class DirectoryRegistrationClient(BaseClient):
             host_ip,
             port,
             user_token_required=True,
-            application_token_required=False,
             liveness_timeout_secs=0,
             **kwargs):
         """Update a service definition of an existing service that matches the service name.
@@ -142,7 +134,6 @@ class DirectoryRegistrationClient(BaseClient):
           host_ip: The ip address of the system that the service is being hosted on.
           port: The port number the service can be accessed through on the host system.
           user_token_required: If a user token should be verified to access the service.
-          application_token_required Deprecated - Do not use.
           liveness_timeout_secs: Number of seconds without directory heartbeat before timeout fault.
 
         Raises:
@@ -150,10 +141,6 @@ class DirectoryRegistrationClient(BaseClient):
           ServiceDoesNotExistError: The service does not exist.
           DirectoryRegistrationResponseError: Something went wrong during the directory registration.
         """
-        if (application_token_required):
-            _LOGGER.warning(
-                'The application_token_required parameter has been deprecated and will have no effect.'
-            )
 
         service_entry = directory_pb2.ServiceEntry(
             name=name,
@@ -274,7 +261,7 @@ def reset_service_registration(
 
     This is useful when a program wants to register a new service but there may be an old entry
     in the robot directory from a previous instance of the program. If the service
-    does not already exists, the exception will be suppressed and a new registration will
+    does not already exist, the exception will be suppressed and a new registration will
     still be performed. Unregistering the service has the advantage of clearing all service
     faults, if any existed.
     """

bosdyn/client/exceptions.py

@@ -81,10 +81,6 @@ class ClientCancelledOperationError(PersistentRpcError):
     """The user cancelled the rpc request."""
 
 
-class InvalidAppTokenError(PersistentRpcError):
-    """The provided app token is invalid."""
-
-
 class InvalidClientCertificateError(PersistentRpcError):
     """The provided client certificate is invalid."""