bosdyn-client 5.0.1.2__py3-none-any.whl → 5.1.0__py3-none-any.whl

bosdyn/client/access_controlled_door_util.py

@@ -0,0 +1,206 @@
+# 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).
+
+import json
+from pathlib import Path
+from string import Template
+
+import requests
+
+from bosdyn.client.url_validation_util import safe_api_call
+
+API_TIMEOUT_DEFAULT = 30
+
+
+def file_to_json(file_path):
+    """
+    Helper to read and parse JSON files.
+    Args:
+        file_path (Path): Path to JSON file.
+    Returns:
+        dict: Parsed JSON data.
+    """
+    return json.loads(file_path.read_text())
+
+
+
+
+# Functions to handle api calls to access control systems
+def door_action(api_calls, door_id, action, path_to_cert=None, is_robot=True):
+    """Executes a sequence of API calls required to perform an action (e.g., open or close) on a specified door,
+    handling data substitutions and certificate verification as needed.
+
+        api_calls (list of dict): List of API call specifications, where each dict contains information
+            such as 'method', 'url', 'action', 'sni_hostname', 'route', 'request_data', and 'responses'.
+        door_id (str): Identifier of the door to perform the action on.
+        action (list of str): The action(s) to perform (e.g., "open", "close"). Only calls matching
+            the specified action(s) will be executed.
+        path_to_cert (str, optional): Path to a certificate file for SSL verification. If None, no certificate
+            is used.
+        is_robot (bool, optional): Indicates if the API calls are being made on behalf of a robot. Defaults to True.
+
+    Returns:
+        dict: An error message dictionary containing details about any error encountered during the API calls.
+            If all calls succeed, returns an empty dictionary.
+    """
+    error_msg = {}
+    cross_call_substitutions = {"door_id": door_id}
+
+    for call_data in api_calls:
+
+        if call_data.get("action") not in action:
+            continue
+
+        method = call_data.get("method")
+        url = call_data.get("url")
+        sni_hostname = call_data.get("sni_hostname")
+        route = call_data.get("route")
+        request_data = call_data.get("request_data", {})
+        responses = call_data.get("responses", {})
+        call_action = call_data.get("action", "")
+
+        if not method or not url:
+            error_msg["extra_message"] = "API call error: missing method or url"
+            break
+
+        # Format URL and data - note: substitutions are case-INsensitive
+        try:
+            # This will only replace instances of values formatted like $variable or ${variable}
+            url = Template(url).safe_substitute(cross_call_substitutions)
+
+            templated_request_data = {}
+            for k, v in request_data.items():
+                if isinstance(v, dict):  # Handle nested dicts, like headers
+                    templated_request_data[k] = {
+                        k2:
+                            Template(v2).safe_substitute(cross_call_substitutions) if isinstance(
+                                v2, str) else v2 for k2, v2 in v.items()
+                    }
+                elif isinstance(v, str):  # Handle top level string values
+                    templated_request_data[k] = Template(v).safe_substitute(
+                        cross_call_substitutions)
+                else:
+                    templated_request_data[k] = v
+            # Check if cert file was included at the configuration, if yes use it
+            if path_to_cert:
+                templated_request_data["verify"] = path_to_cert
+        except Exception as e:
+            print(f"{e} has no value, couldn't make substitution")
+
+        result_of_call, api_error_msg = make_access_control_system_api_call(
+            method, url, templated_request_data, responses, sni_hostname=sni_hostname,
+            is_robot=is_robot, route=route)
+        if api_error_msg:
+            error_msg["action"] = call_action
+            error_msg["api_error"] = api_error_msg
+            break
+
+        # If the call returned data, store it for subsequent calls
+        if result_of_call:
+            try:
+                for result in result_of_call:
+                    tag = result[0]
+                    content = result[1]
+                    cross_call_substitutions[tag] = content
+            except Exception as e:
+                print(f"API call error: couldn't read data, got exception {e}")
+                error_msg["extra_message"] = f"API call error: couldn't read data, got exception"
+                break
+    return error_msg
+
+
+
+
+def make_access_control_system_api_call(method, url, request_data, store_responses=None,
+                                        sni_hostname=None, is_robot=True, route=None):
+    """Makes an HTTP request and optionally extracts specific fields from the JSON response.
+    
+    Args:
+        method (str): HTTP method to use (e.g., 'GET', 'POST')
+        url (str): The endpoint URL for the API call
+        request_data (dict): Request configuration including headers, body, etc.
+        store_responses (Optional[Dict[str, str]]): Dictionary mapping response field names to 
+            JSON paths. For example:
+            {
+                "token": "auth.token",  # Store response's auth.token as "token"
+                "session_id": "data.session"  # Store response's data.session as "session_id"
+            }
+            If None, no data will be extracted from the response.
+        sni_hostname (str|None): If specified, this parameter provides the hostname declared by
+            and expected by the access control server during TLS negotiation. This should only be
+            required if the server's hostname is not resolvable via DNS.
+        route (str|None): Route type to use ("WIFI", "LTE").
+            If None, default interface (WIFI) will be used.
+    
+    Returns:
+        Tuple[Optional[List[Tuple[str, Any]]], Optional[Dict]]:
+            - First element: If store_responses was provided and matching data was found,
+              returns list of tuples [(field_name, value), ...]. None otherwise.
+            - Second element: If error occurred, returns dict with error details:
+              {
+                  'status_code': int,
+                  'reason': str,
+                  'elapsed': float
+              }
+              None if successful.
+    
+    Example:
+        >>> store_responses = {"auth_token": "data.token"}
+        >>> data, error = make_access_control_system_api_call("POST", "https://api.door/auth",
+        ...                                                   {"json": {"key": "value"}},
+        ...                                                   store_responses)
+        >>> if data:
+        ...     # data might be [("auth_token", "abc123")]
+        ...     token = dict(data)["auth_token"]
+    """
+    try:
+        response, status_message = safe_api_call(method, url, sni_hostname,
+                                                 timeout=API_TIMEOUT_DEFAULT, is_robot=is_robot,
+                                                 interface=route, **request_data)
+
+        if response is None:
+            # There was an error during the API call
+            return None, status_message
+
+        if response.status_code == 200:
+            if store_responses:
+                # Only try to parse JSON and extract data if we need to store responses
+                data_json = response.json()
+                return [(tag, get_value_by_path(data_json, path))
+                        for tag, path in store_responses.items()
+                        if get_value_by_path(data_json, path) is not None], None
+            # If we don't need to store responses, just return success
+            return None, None
+
+        # If the status code isn't 200, something went wrong
+        return None, {
+            'status_code': response.status_code,
+            'reason': response.reason,
+            'elapsed': response.elapsed.total_seconds(),
+        }
+
+    except requests.exceptions.RequestException as e:
+        print(f"API call failed: {str(e)}")
+        return None, {
+            'status_code': getattr(e.response, 'status_code', None),
+            'reason': getattr(e.response, 'reason', str(e)),
+            'elapsed': getattr(e.response, 'elapsed', None)
+        }
+
+
+def get_value_by_path(data_json, path_to_info):
+    """Takes in a json representing the data of a call response, and a string representing the 
+        path through the json to the desired data. Traverses the json and returns the data.      
+    """
+    keys = path_to_info.split('.')
+    result = data_json
+
+    for key in keys:
+        result = result.get(key, None)
+    if result is not None:
+        return result
+    else:
+        return False

bosdyn/client/arm_surface_contact.py

@@ -4,8 +4,8 @@
 # is subject to the terms and conditions of the Boston Dynamics Software
 # Development Kit License (20191101-BDSDK-SL).
 
-from bosdyn.api import arm_surface_contact_pb2, arm_surface_contact_service_pb2_grpc
-from bosdyn.client.common import BaseClient, common_header_errors
+from bosdyn.api import arm_surface_contact_service_pb2_grpc
+from bosdyn.client.common import BaseClient
 from bosdyn.client.robot_command import NoTimeSyncError, _edit_proto, _TimeConverter
 
 from .lease import add_lease_wallet_processors

bosdyn/client/async_tasks.py

@@ -6,7 +6,8 @@
 
 """Utilities for managing periodic tasks consisting of asynchronous GRPC calls."""
 import abc
-import time
+
+from bosdyn.util import now_sec
 
 from .exceptions import ResponseError, RpcError
 
@@ -79,7 +80,7 @@ class AsyncGRPCTask(object, metaclass=abc.ABCMeta):
 
     def update(self):
         """Call this periodically to manage execution of task represented by this object."""
-        now_sec = time.time()
+        now_sec = now_sec()
         if self._future is not None:
             if self._future.original_future.done():
                 try:

bosdyn/client/audio_visual_helpers.py

@@ -13,6 +13,7 @@ import bosdyn.client
 from bosdyn.api import audio_visual_pb2
 from bosdyn.client.audio_visual import (AudioVisualClient, BehaviorExpiredError, DoesNotExistError,
                                         InvalidClientError)
+from bosdyn.util import now_sec
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -84,7 +85,7 @@ class AudioVisualHelper:
         # Run the AV behavior until the stop_event is triggered
         while not self.stop_event.wait(self.refresh_rate):
             try:
-                end_time_secs = time.time() + self.refresh_rate + 0.10  # add 100ms margin
+                end_time_secs = now_sec() + self.refresh_rate + 0.10  # add 100ms margin
                 result = self.av_client.run_behavior(self.behavior_name, end_time_secs)
                 set_future_result(
                     result.run_result == audio_visual_pb2.RunBehaviorResponse.RESULT_BEHAVIOR_RUN)
@@ -109,4 +110,4 @@ class AudioVisualHelper:
         try:
             self.av_client.stop_behavior(self.behavior_name)
         except InvalidClientError:
-            _LOGGER.warning('Failed to stop behavior, run by a different client.')
+            _LOGGER.warning('Failed to stop behavior, run by a different client.')

bosdyn/client/autowalk.py

@@ -14,8 +14,6 @@ from bosdyn.client.common import BaseClient, error_factory, error_pair
 from bosdyn.client.exceptions import ResponseError
 from bosdyn.client.lease import add_lease_wallet_processors
 
-from .data_chunk import chunk_message
-
 
 class AutowalkResponseError(ResponseError):
     """General class of errors for autowalk service."""

bosdyn/client/command_line.py

@@ -12,6 +12,7 @@ from __future__ import division
 
 import abc
 import argparse
+import copy
 import datetime
 import os
 import signal
@@ -19,17 +20,19 @@ import socket
 import sys
 import threading
 import time
+import uuid
 
-from deprecated.sphinx import deprecated
+import google.protobuf.timestamp_pb2
 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.header_pb2 import CommonError
 from bosdyn.api.keepalive import keepalive_pb2
 from bosdyn.api.robot_state_pb2 import BehaviorFault
-from bosdyn.util import duration_str, timestamp_to_datetime
+from bosdyn.util import duration_str, now_sec, timestamp_to_datetime
 
 from .auth import InvalidLoginError, InvalidTokenError
 from .data_acquisition import DataAcquisitionClient
@@ -715,6 +718,7 @@ class LogStatusCommands(Subcommands):
                 GetActiveLogStatusesCommand,
                 ExperimentLogCommand,
                 StartRetroLogCommand,
+                StartConcurrentLogCommand,
                 TerminateLogCommand,
             ])
 
@@ -920,6 +924,53 @@ class StartRetroLogCommand(Command):
         return True
 
 
+class StartConcurrentLogCommand(Command):
+    """Start a concurrent experiment log, with event-derived data."""
+
+    NAME = 'concurrent'
+
+    def __init__(self, subparsers, command_dict):
+        """Start data log
+        Args:
+            subparsers: List of argument parsers.
+            command_dict: Dictionary of command names which take parsed options.
+        """
+        super(StartConcurrentLogCommand, self).__init__(subparsers, command_dict)
+        self._parser.add_argument('seconds', type=float, help='how long should the experiment run?')
+        self._parser.add_argument('event_type',
+                                  help='name of the event type we want to match a recipe against')
+
+    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(LogStatusClient.default_service_name)
+        time_sync_endpoint = TimeSyncEndpoint(
+            robot.ensure_client(TimeSyncClient.default_service_name))
+        if not time_sync_endpoint.establish_timesync():
+            print("Failed to establish time sync with the robot.")
+            return False
+
+        robot_now = time_sync_endpoint.robot_timestamp_from_local_secs(now_sec())
+
+        event = Event()
+        event.type = options.event_type
+        event.description = 'Triggering a recipe data log'
+        event.source = 'LogStatus CLI'
+        event.id = uuid.uuid4().hex
+        event.start_time.CopyFrom(robot_now)
+        event.end_time.CopyFrom(robot_now)
+
+        response = client.start_concurrent_log(options.seconds, event)
+        print(response.log_status)
+        return True
+
+
 class TerminateLogCommand(Command):
     """Terminate log gathering process."""
 
@@ -1054,7 +1105,7 @@ class TextMsgCommand(Command):
         if options.timestamp:
             try:
                 robot_timestamp = robot.time_sync.robot_timestamp_from_local_secs(
-                    time.time(), timesync_timeout_sec=1.0)
+                    now_sec(), timesync_timeout_sec=1.0)
             except TimeSyncError as err:
                 print("Failed to send message with timestamp: {}.".format(err))
                 return False
@@ -1107,7 +1158,7 @@ class OperatorCommentCommand(Command):
         """
         client_timestamp = None
         if options.timestamp:
-            client_timestamp = time.time()
+            client_timestamp = now_sec()
             try:
                 robot.time_sync.wait_for_sync(timeout_sec=1.0)
             except TimeSyncError as err:
@@ -2648,6 +2699,10 @@ class PowerWifiRadioCommand(Command):
 
 
 
+
+
+
+
 def main(args=None):
     """Command-line interface for interacting with robot services."""
     parser = argparse.ArgumentParser(prog='bosdyn.client', description=main.__doc__)
@@ -2675,9 +2730,11 @@ def main(args=None):
     LocalGridCommands(subparsers, command_dict)
     DataAcquisitionCommand(subparsers, command_dict)
     HostComputerIPCommand(subparsers, command_dict)
+    VideoRecordingCommands(subparsers, command_dict)
     PowerCommand(subparsers, command_dict)
     KeepaliveCommand(subparsers, command_dict)
 
+
     options = parser.parse_args(args=args)
 
     setup_logging(verbose=options.verbose)

bosdyn/client/common.py

@@ -25,7 +25,7 @@ from .exceptions import (CustomParamError, Error, InternalServerError, InvalidRe
 
 _LOGGER = logging.getLogger(__name__)
 
-from bosdyn.api import data_chunk_pb2, license_pb2
+from bosdyn.api import license_pb2
 
 DEFAULT_RPC_TIMEOUT = 30  # seconds
 

bosdyn/client/data_acquisition.py

@@ -8,15 +8,13 @@
 
 import collections
 
-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, 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
+                                  handle_unset_status_error)
+from bosdyn.client.exceptions import InternalServerError, ResponseError
+from bosdyn.util import now_sec, now_timestamp, seconds_to_duration
 
 
 class DataAcquisitionResponseError(ResponseError):

bosdyn/client/data_acquisition_helpers.py

@@ -12,11 +12,8 @@ from urllib.error import URLError
 from urllib.parse import urlencode
 from urllib.request import Request, urlopen
 
-from google.protobuf import json_format
 from google.protobuf.struct_pb2 import Struct
 
-import bosdyn.client
-import bosdyn.client.util
 from bosdyn.api import data_acquisition_pb2, data_acquisition_store_pb2
 from bosdyn.client.exceptions import ResponseError
 

bosdyn/client/data_acquisition_plugin.py

@@ -15,8 +15,7 @@ from bosdyn.client.common import (BaseClient, error_factory, error_pair,
                                   handle_unset_status_error)
 from bosdyn.client.data_acquisition import (DataAcquisitionClient, DataAcquisitionResponseError,
                                             UnknownCaptureTypeError, _get_live_data_error,
-                                            acquire_data_error, get_request_id, metadata_to_proto)
-from bosdyn.util import now_timestamp
+                                            acquire_data_error, metadata_to_proto)
 
 
 class DataAcquisitionPluginClient(BaseClient):

bosdyn/client/data_acquisition_plugin_service.py

@@ -54,6 +54,7 @@ from bosdyn.client.data_acquisition_store import DataAcquisitionStoreClient
 from bosdyn.client.data_buffer import DataBufferClient
 from bosdyn.client.server_util import ResponseContext, populate_response_header
 from bosdyn.client.service_customization_helpers import create_value_validator
+from bosdyn.util import now_sec
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -590,7 +591,7 @@ class RequestManager:
         """
         state = self.get_request_state(request_id)
         with state._lock:
-            state._completion_time = time.time()
+            state._completion_time = now_sec()
 
     def cleanup_requests(self, older_than_time=None):
         """Remove all requests that were completed farther in the past than older_than_time.
@@ -600,7 +601,7 @@ class RequestManager:
         Args:
             older_than_time (float): Optional time (in seconds) that requests will be removed after.
         """
-        older_than_time = older_than_time or time.time() - kDefaultRequestExpiration
+        older_than_time = older_than_time or now_sec() - kDefaultRequestExpiration
         with self._lock:
             # Grab the contents to iterate through outside of the lock
             requests = list(self._requests.items())

bosdyn/client/data_acquisition_store.py

@@ -10,18 +10,12 @@
 from os import fstat
 from pathlib import Path
 
-from google.protobuf import json_format
-
 from bosdyn.api import data_acquisition_store_pb2 as data_acquisition_store
 from bosdyn.api import data_acquisition_store_service_pb2_grpc as data_acquisition_store_service
 from bosdyn.api import data_chunk_pb2 as data_chunk
-from bosdyn.api import header_pb2, image_pb2
 from bosdyn.client.channel import DEFAULT_HEADER_BUFFER_LENGTH, DEFAULT_MAX_MESSAGE_LENGTH
-from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,
-                                  handle_common_header_errors, handle_unset_status_error)
+from bosdyn.client.common import BaseClient, common_header_errors
 from bosdyn.client.data_chunk import split_serialized
-from bosdyn.client.exceptions import Error, ResponseError
-from bosdyn.util import now_timestamp
 
 DEFAULT_CHUNK_SIZE_BYTES = int(DEFAULT_MAX_MESSAGE_LENGTH - DEFAULT_HEADER_BUFFER_LENGTH)
 

bosdyn/client/data_buffer.py

@@ -28,6 +28,7 @@ from bosdyn.api import parameter_pb2
 from bosdyn.client import time_sync
 from bosdyn.client.common import BaseClient, common_header_errors
 from bosdyn.client.exceptions import Error, ResponseError, RpcError
+from bosdyn.util import now_sec
 
 
 class InvalidArgument(Error):
@@ -356,7 +357,7 @@ class DataBufferClient(BaseClient):
                     (msg_type if msg_type is not None else
                      (proto.DESCRIPTOR.full_name if proto is not None else 'Unknown')))
             else:
-                return converter.robot_timestamp_from_local_secs(time.time())
+                return converter.robot_timestamp_from_local_secs(now_sec())
         return None
 
 
@@ -430,7 +431,7 @@ class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attr
         msg = self.record_to_msg(record)
         with self._lock:
             self._msg_queue.append(msg)
-        self._last_emit_time = time.time()
+        self._last_emit_time = now_sec()
 
     def flush(self):
         self._flush_event.set()
@@ -487,7 +488,7 @@ class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attr
         while (self._num_failed_sends_sequential < self._limit_failed_sends_sequential and
                not self._shutdown_event.is_set()):
             flush = self._flush_event.wait(self._flush_event_wait_time)
-            msg_age = time.time() - self._last_emit_time
+            msg_age = now_sec() - self._last_emit_time
             with self._lock:
                 num_msgs = len(self._msg_queue)
                 to_send = self._msg_queue[:num_msgs]
@@ -555,7 +556,7 @@ class LoggingHandler(logging.Handler):  # pylint: disable=too-many-instance-attr
         if self.time_sync_endpoint is not None:
             try:
                 msg.timestamp.CopyFrom(
-                    self.time_sync_endpoint.robot_timestamp_from_local_secs(time.time()))
+                    self.time_sync_endpoint.robot_timestamp_from_local_secs(now_sec()))
             except time_sync.NotEstablishedError:
                 # If timestamp is not set in the proto, data-buffer will timestamp it on receipt.
                 msg.message = '(No time sync!): ' + msg.message

bosdyn/client/directory_registration.py

@@ -18,6 +18,7 @@ from bosdyn.api import (directory_pb2, directory_registration_pb2,
                         directory_registration_service_pb2_grpc)
 from bosdyn.client.common import (BaseClient, error_factory, error_pair,
                                   handle_common_header_errors, handle_unset_status_error)
+from bosdyn.util import now_sec
 
 from .error_callback_result import ErrorCallbackResult
 from .exceptions import ResponseError, RetryableUnavailableError, RpcError, TimedOutError
@@ -442,7 +443,7 @@ class DirectoryRegistrationKeepAlive(object):
 
         self.logger.info('Starting directory registration loop for {}'.format(self.directory_name))
         while not self._end_reregister_signal.wait(wait_time):
-            exec_start = time.time()
+            exec_start = now_sec()
             action = ErrorCallbackResult.RESUME_NORMAL_OPERATION
             try:
                 self.dir_reg_client.register(
@@ -476,7 +477,7 @@ class DirectoryRegistrationKeepAlive(object):
                 # Log all other exceptions, but continue looping in hopes that it resolves itself
                 self.logger.exception('Caught general exception')
 
-            elapsed = time.time() - exec_start
+            elapsed = now_sec() - exec_start
             if action == ErrorCallbackResult.RETRY_IMMEDIATELY:
                 wait_time = 0.0
             elif action == ErrorCallbackResult.ABORT:

bosdyn/client/estop.py

@@ -18,6 +18,7 @@ import time
 from google.protobuf.duration_pb2 import Duration
 
 from bosdyn.api import estop_pb2, estop_service_pb2_grpc
+from bosdyn.util import now_sec
 
 from .common import (BaseClient, common_header_errors, error_factory, handle_common_header_errors,
                      handle_unset_status_error)
@@ -578,7 +579,7 @@ class EstopKeepAlive(object):
         while True:
             # Include the time it takes to execute keep_running, in case it takes a significant
             # portion of our check in period.
-            exec_start = time.time()
+            exec_start = now_sec()
             if not self._keep_running():
                 break
             try:
@@ -604,7 +605,7 @@ class EstopKeepAlive(object):
                 self._ok()
 
             # How long did the RPC and processing of said RPC take?
-            exec_sec = time.time() - exec_start
+            exec_sec = now_sec() - 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!

bosdyn/client/fault.py

@@ -8,7 +8,7 @@
 import collections
 
 from bosdyn.api import fault_service_pb2_grpc, service_fault_pb2
-from bosdyn.client.common import (BaseClient, common_header_errors, error_factory, error_pair,
+from bosdyn.client.common import (BaseClient, error_factory, error_pair,
                                   handle_common_header_errors, handle_unset_status_error)
 
 from .exceptions import ResponseError

bosdyn/client/gps/aggregator_client.py

@@ -6,10 +6,8 @@
 
 """For clients to use the Gps Aggregator service."""
 
-from bosdyn.api.gps import aggregator_pb2, aggregator_service_pb2_grpc, gps_pb2
-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 ResponseError
+from bosdyn.api.gps import aggregator_pb2, aggregator_service_pb2_grpc
+from bosdyn.client.common import BaseClient, handle_common_header_errors
 
 
 class AggregatorClient(BaseClient):

bosdyn/client/gps/gps_listener.py

@@ -11,15 +11,13 @@ import socket
 import time
 from typing import List
 
-import bosdyn.api
-import bosdyn.client.util
 from bosdyn.api.gps.gps_pb2 import GpsDataPoint, GpsDevice
 from bosdyn.client.exceptions import ProxyConnectionError
 from bosdyn.client.gps.aggregator_client import AggregatorClient
 from bosdyn.client.gps.NMEAParser import NMEAParser
 from bosdyn.client.gps.ntrip_client import NtripClient, NtripClientParams
 from bosdyn.client.robot import UnregisteredServiceNameError
-from bosdyn.util import RobotTimeConverter, duration_to_seconds
+from bosdyn.util import RobotTimeConverter, now_sec
 
 
 class NMEAStreamReader(object):
@@ -44,7 +42,7 @@ class NMEAStreamReader(object):
                 raw_data = str(raw_data, "utf-8")
         except UnicodeDecodeError:
             # Throttle the logs.
-            now = time.time()
+            now = now_sec()
             if self.last_failed_read_log_time is None or (
                     now - self.last_failed_read_log_time) > self.LOG_THROTTLE_TIME:
                 self.logger.exception("Failed to decode NMEA message. Is it not Unicode?")
@@ -160,17 +158,17 @@ class GpsListener:
                         agg_future = self.aggregator_client.new_gps_data_async(
                             accumulated_data, self.gps_device)
                         accumulated_data.clear()
-                        timestamp_of_last_rpc = time.time()
+                        timestamp_of_last_rpc = now_sec()
                         time_passed_since_last_rpc = 0
                 else:
                     if time_passed_since_last_rpc > every_x_seconds:
                         if agg_future is None or agg_future.done():
                             agg_future = self.aggregator_client.new_gps_data_async([],
                                                                                    self.gps_device)
-                        timestamp_of_last_rpc = time.time()
+                        timestamp_of_last_rpc = now_sec()
                         time_passed_since_last_rpc = 0
                     else:
-                        time_passed_since_last_rpc = time.time() - timestamp_of_last_rpc
+                        time_passed_since_last_rpc = now_sec() - timestamp_of_last_rpc
 
                 # If we are running an NTRIP client, pass it the latest GGA message.
                 if self.ntrip_client is not None: