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

bosdyn/client/__init__.py

@@ -8,18 +8,17 @@
 Sets up some convenience imports for commonly used classes.
 """
 # yapf: enable
-from .auth import (AuthClient, ExpiredApplicationTokenError, InvalidApplicationTokenError,
-                   InvalidLoginError, InvalidTokenError)
+from .auth import AuthClient, InvalidLoginError, InvalidTokenError
 from .common import BaseClient
 # yapf: disable
 from .exceptions import (ClientCancelledOperationError, CustomParamError, Error,
-                         InternalServerError, InvalidAppTokenError, InvalidClientCertificateError,
-                         InvalidRequestError, LeaseUseError, LicenseError,
-                         NonexistentAuthorityError, NotFoundError, PersistentRpcError,
-                         ProxyConnectionError, ResponseError, RetryableRpcError,
+                         InternalServerError, InvalidClientCertificateError, InvalidRequestError,
+                         LeaseUseError, LicenseError, NonexistentAuthorityError, NotFoundError,
+                         PersistentRpcError, ProxyConnectionError, ResponseError, RetryableRpcError,
                          RetryableUnavailableError, RpcError, ServerError,
                          ServiceFailedDuringExecutionError, ServiceUnavailableError, TimedOutError,
                          TooManyRequestsError, UnableToConnectToRobotError, UnauthenticatedError,
                          UnimplementedError, UnknownDnsNameError, UnsetStatusError)
 from .robot import Robot
 from .sdk import BOSDYN_RESOURCE_ROOT, Sdk, create_standard_sdk
+

bosdyn/client/area_callback_region_handler_base.py

@@ -50,6 +50,15 @@ class CallbackTimedOutError(HandlerError):
     re-raised to make sure the response is set correctly."""
 
 
+class RouteChangedResult:
+    """Options for how the helper class should respond to a route change."""
+
+    def __init__(self):
+        # Specify that if the callback has stopped (returned or raised from run()) that run()
+        # should be called again.
+        self.rerun_if_stopped = False
+
+
 class AreaCallbackRegionHandlerBase:
     """Base class for implementing a AreaCallbackRegionHandler.
 
@@ -100,6 +109,12 @@ class AreaCallbackRegionHandlerBase:
         """This function is called after run thread has finished and client calls EndCallback."""
         raise NotImplementedError("Derived class must implement this function.")
 
+    def route_changed(self, request: area_callback_pb2.RouteChangeRequest) -> RouteChangedResult:
+        """This function is called when Graph Nav re-routes inside the callback region.
+        In most cases, the callback does not need to do anything for this case and can leave the
+        default implementation"""
+        return RouteChangedResult()
+
     @property
     def area_callback_information(self) -> area_callback_pb2.AreaCallbackInformation:
         """Get area_callback_pb2.AreaCallbackInformation."""
@@ -155,10 +170,10 @@ class AreaCallbackRegionHandlerBase:
             self._update_response.complete.SetInParent()
 
     def set_localization_at_end(self):
-        """Set the localization hint to the end of the callback region, indicating that graph nav 
+        """Set the localization hint to the end of the callback region, indicating that graph nav
         that navigation should continue from this point.
         Robot control is required to set this. It should be called after walking to the end of
-        the region, but before ceding control. 
+        the region, but before ceding control.
 
         Raises:
             IncorrectUsage: When called without robot control.
@@ -243,7 +258,7 @@ class AreaCallbackRegionHandlerBase:
             sleep_time_secs (float): Time to sleep, in seconds.
 
         Raises:
-            HandlerError: When a shutdown is requested during the sleep time..
+            HandlerError: When a shutdown is requested during the sleep time.
         """
         if self.robot.time_sec() > self._end_time:
             raise CallbackTimedOutError()
@@ -318,7 +333,7 @@ class AreaCallbackRegionHandlerBase:
         """Wrapper around the run function which catches exceptions and set update response.
 
         Args:
-            shutdown_event (Event): Event that signals the run thread to shutdown.
+            shutdown_event (Event): Event that signals the run thread to shut down.
         """
         self._shutdown_event = shutdown_event
         _LOGGER.info('Beginning callback')

bosdyn/client/area_callback_service_servicer.py

@@ -159,6 +159,34 @@ class AreaCallbackServiceServicer(area_callback_service_pb2_grpc.AreaCallbackSer
             self.area_callback_region_handler = None
         return response
 
+    def RouteChange(self, request, context):
+        """Called when we re-route within the callback.  Most callbacks do not need to know about
+        changes in the route, and can ignore this."""
+        _LOGGER.info('Received RouteChange for command %d', request.command_id)
+        response = area_callback_pb2.RouteChangeResponse()
+        with ResponseContext(response, request, self._rpc_logger):
+            if (not self.area_callback_region_handler or
+                    not self._is_active_command_id(request.command_id)):
+                response.status = area_callback_pb2.EndCallbackResponse.STATUS_INVALID_COMMAND_ID
+                return response
+            try:
+                route_changed_result = self.area_callback_region_handler.route_changed(request)
+                if (route_changed_result.rerun_if_stopped and
+                        not self.area_callback_active_thread.is_alive()):
+                    self.area_callback_active_thread_event = Event()
+                    self.area_callback_active_thread = Thread(
+                        target=self.area_callback_region_handler.internal_run_wrapper,
+                        args=[self.area_callback_active_thread_event])
+                    self.area_callback_active_thread.start()
+                    _LOGGER.info('Re-created thread for command id %d', self._active_command_id)
+                response.status = response.STATUS_OK
+            except Exception as exc:
+                _LOGGER.exception("Failed route_changed_call")
+                response.header.error.code = response.header.error.CODE_INTERNAL_SERVER_ERROR
+                response.header.error.message = str(exc)
+
+        return response
+
     def _is_expired(self, end_time):
         current_robot_time_secs = self.robot.time_sec()
         end_time_secs = timestamp_to_sec(end_time)
@@ -213,7 +241,7 @@ class AreaCallbackServiceServicer(area_callback_service_pb2_grpc.AreaCallbackSer
         """Call to force run thread to terminate.
 
         Args:
-            timeout (float, optional): Time allowed to run thread to shutdown. Defaults to 5.
+            timeout (float, optional): Time allowed to run thread to shut down. Defaults to 5.
 
         Returns:
             bool: True if the thread correctly shut down within the allowed time.

bosdyn/client/area_callback_service_utils.py

@@ -8,13 +8,13 @@ import logging
 import time
 from typing import List
 
+import bosdyn.client
 from bosdyn.api import service_fault_pb2
 from bosdyn.api.graph_nav import area_callback_pb2
 from bosdyn.api.service_customization_pb2 import DictParam
 from bosdyn.client.directory import NonexistentServiceError
-from bosdyn.client.exceptions import RpcError
-from bosdyn.client.fault import (FaultResponseError, ServiceFaultAlreadyExistsError,
-                                 ServiceFaultDoesNotExistError)
+from bosdyn.client.fault import ServiceFaultAlreadyExistsError, ServiceFaultDoesNotExistError
+from bosdyn.client.service_customization_helpers import dict_params_to_dict
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -43,49 +43,18 @@ class AreaCallbackServiceConfig:
 
     def parse_params(self, params: DictParam):
         """ Parse params and validate they agree with the spec stored in area_callback_information.
-        
+
         Args:
             params (DictParam): The parameters being validated.
         """
-
-        spec = self.area_callback_information.custom_params
-        values = {}
-        for (key, param) in params.values.items():
-            if key not in spec.specs:
-                raise ValueError(f"No spec provided for parameter {key}.")
-
-            param_spec = spec.specs[key].spec
-            spec_field = param_spec.WhichOneof("spec")
-            value_field = spec_field.replace("spec", "value")
-            if not param.HasField(value_field):
-                raise ValueError(f"Param {key} has a {spec_field}, but has no {value_field}.")
-
-            type_spec = getattr(param_spec, spec_field)
-            param_value = getattr(param, value_field)
-
-            # For numerical values, check bounds.
-            if hasattr(type_spec, "min_value") and \
-                type_spec.HasField("min_value") and \
-                param_value.value < type_spec.min_value.value:
-                raise ValueError(f"Value for {key} too low; minimum is {type_spec.min_value.value} " \
-                                f"but passed value of {param_value.value}")
-
-            if hasattr(type_spec, "max_value") and \
-                type_spec.HasField("max_value") and \
-                param_value.value > type_spec.max_value.value:
-                raise ValueError(f"Value for {key} too high; maximum is {type_spec.max_value.value} " \
-                                f"but passed value of {param_value.value}")
-
-            values[key] = param_value.value
-
-        return values
+        return dict_params_to_dict(params, self.area_callback_information.custom_params)
 
 
 # Helper to raise service faults when other services are unavailable.
 def handle_service_faults(fault_client, robot_state_client, directory_client, service_name,
                           prereq_services):
     service_fault = service_fault_pb2.ServiceFault()
-    service_fault.fault_id.fault_name = f'{service_name}'
+    service_fault.fault_id.fault_name = service_name
     service_fault.fault_id.service_name = service_name
     service_fault.severity = service_fault_pb2.ServiceFault.SEVERITY_CRITICAL
     check_period = 0.5  # seconds.
@@ -98,43 +67,68 @@ def handle_service_faults(fault_client, robot_state_client, directory_client, se
             registered_service = directory_client.get_entry(service_name)
         except NonexistentServiceError as exc:
             continue
+        except bosdyn.client.Error as exc:
+            _LOGGER.error("Failed to check if %s exists during fault handling: %s", service_name,
+                          exc)
+            continue
 
         set_fault = False
+        fault_exists = False
         unavailable_services = []
-        for service in prereq_services:
+
+        # Need robot state to check existing faults.
+        try:
+            state = robot_state_client.get_robot_state()
+        except bosdyn.client.Error as exc:
+            _LOGGER.error("Failed to get robot state during fault handling: %s", exc)
+            continue
+
+        for prereq_service in prereq_services:
             # Make sure the prereq service exists.
             try:
-                registered_service = directory_client.get_entry(service)
+                registered_service = directory_client.get_entry(prereq_service)
             except NonexistentServiceError as exc:
                 set_fault = True
-                unavailable_services.append(service)
+                unavailable_services.append(prereq_service)
+                continue
+            except bosdyn.client.Error as exc:
+                _LOGGER.error("Failed to check if %s exists during fault handling: %s",
+                              prereq_service, exc)
+                set_fault = True
+                unavailable_services.append(prereq_service)
                 continue
 
             # Make sure the prereq service isn't faulted.
-            state = robot_state_client.get_robot_state()
             for fault in state.service_fault_state.faults:
-                if fault.fault_id.service_name == service:
+                if fault.fault_id.service_name == prereq_service:
                     set_fault = True
-                    unavailable_services.append(service)
+                    unavailable_services.append(prereq_service)
                     break
 
-        # Fault the service.
-        if set_fault:
+        # Check if the service is already faulted.
+        for fault in state.service_fault_state.faults:
+            if fault.fault_id.service_name == service_name:
+                fault_exists = True
+                break
+
+        # Fault the service if there isn't an existing fault.
+        if set_fault and not fault_exists:
             service_fault.error_message = 'Faulted due to issues with ' + ','.join(
                 unavailable_services)
             try:
                 fault_client.trigger_service_fault(service_fault)
+                _LOGGER.info("Triggered fault on %s", service_name)
             except ServiceFaultAlreadyExistsError:
                 pass
-            except (RpcError, FaultResponseError) as exc:
-                _LOGGER.error(f"Failed to set {service_name} fault. {exc}")
+            except bosdyn.client.Error as exc:
+                _LOGGER.error("Failed to set %s fault: %s", service_name, exc)
 
         # Otherwise, clear the fault if it exists.
-        else:
+        elif not set_fault and fault_exists:
             try:
                 fault_client.clear_service_fault(service_fault.fault_id)
-                set_fault = False
+                _LOGGER.info("Cleared fault on %s", service_name)
             except ServiceFaultDoesNotExistError:
                 pass
-            except (RpcError, FaultResponseError) as exc:
-                _LOGGER.error(f"Failed to clear {service_name} fault. {exc}")
+            except bosdyn.client.Error as exc:
+                _LOGGER.error("Failed to clear %s fault: %s", service_name, exc)

bosdyn/client/auth.py

@@ -39,14 +39,6 @@ class TemporarilyLockedOutError(AuthResponseError):
     """User is temporarily locked out of authentication."""
 
 
-class ExpiredApplicationTokenError(AuthResponseError):
-    """Application token has expired. Please contact support@bostondynamics.com to receive a new one."""
-
-
-class InvalidApplicationTokenError(AuthResponseError):
-    """The Application Token is invalid."""
-
-
 _STATUS_TO_ERROR = collections.defaultdict(lambda: (ResponseError, None))
 _STATUS_TO_ERROR.update({
     auth_pb2.GetAuthTokenResponse.STATUS_OK: (None, None),
@@ -55,11 +47,7 @@ _STATUS_TO_ERROR.update({
     auth_pb2.GetAuthTokenResponse.STATUS_INVALID_TOKEN:
         (InvalidTokenError, InvalidTokenError.__doc__),
     auth_pb2.GetAuthTokenResponse.STATUS_TEMPORARILY_LOCKED_OUT:
-        (TemporarilyLockedOutError, TemporarilyLockedOutError.__doc__),
-    auth_pb2.GetAuthTokenResponse.STATUS_INVALID_APPLICATION_TOKEN:
-        (InvalidApplicationTokenError, InvalidApplicationTokenError.__doc__),
-    auth_pb2.GetAuthTokenResponse.STATUS_EXPIRED_APPLICATION_TOKEN:
-        (ExpiredApplicationTokenError, ExpiredApplicationTokenError.__doc__)
+        (TemporarilyLockedOutError, TemporarilyLockedOutError.__doc__)
 })
 
 
@@ -76,13 +64,12 @@ def _token_from_response(response):
     return response.token
 
 
-def _build_auth_request(username, password, app_token=None):
-    return auth_pb2.GetAuthTokenRequest(username=username, password=password,
-                                        application_token=app_token)
+def _build_auth_request(username, password):
+    return auth_pb2.GetAuthTokenRequest(username=username, password=password)
 
 
-def _build_auth_token_request(token, app_token=None):
-    return auth_pb2.GetAuthTokenRequest(token=token, application_token=app_token)
+def _build_auth_token_request(token):
+    return auth_pb2.GetAuthTokenRequest(token=token)
 
 
 class AuthClient(BaseClient):
@@ -96,13 +83,12 @@ class AuthClient(BaseClient):
     def __init__(self, name=None):
         super(AuthClient, self).__init__(auth_service_pb2_grpc.AuthServiceStub, name=name)
 
-    def auth(self, username, password, app_token=None, **kwargs):
+    def auth(self, username, password, **kwargs):
         """Authenticate to the robot with a username/password combo.
 
         Args:
             username: username on the robot.
             password: password for the username on the robot.
-            app_token: Deprecated.  Only include for robots with old software.
             kwargs: extra arguments for controlling RPC details.
 
         Returns:
@@ -111,25 +97,24 @@ class AuthClient(BaseClient):
         Raises:
             InvalidLoginError: If username and/or password are not valid.
         """
-        req = _build_auth_request(username, password, app_token)
+        req = _build_auth_request(username, password)
         return self.call(self._stub.GetAuthToken, req, _token_from_response, _error_from_response,
                          copy_request=False, **kwargs)
 
-    def auth_async(self, username, password, app_token=None, **kwargs):
+    def auth_async(self, username, password, **kwargs):
         """Asynchronously authenticate to the robot with a username/password combo.
 
         See auth documentation for more details.
         """
-        req = _build_auth_request(username, password, app_token)
+        req = _build_auth_request(username, password)
         return self.call_async(self._stub.GetAuthToken, req, _token_from_response,
                                _error_from_response, copy_request=False, **kwargs)
 
-    def auth_with_token(self, token, app_token=None, **kwargs):
+    def auth_with_token(self, token, **kwargs):
         """Authenticate to the robot using a previously created user token.
 
         Args:
             token: a user token previously issued by the robot.
-            app_token: Deprecated.  Only include for robots with old software.
             kwargs: extra arguments for controlling RPC details.
 
         Returns:
@@ -140,15 +125,15 @@ class AuthClient(BaseClient):
         Raises:
             InvalidTokenError: If the token was incorrectly formed, for the wrong robot, or expired.
         """
-        req = _build_auth_token_request(token, app_token)
+        req = _build_auth_token_request(token)
         return self.call(self._stub.GetAuthToken, req, _token_from_response, _error_from_response,
                          copy_request=False, **kwargs)
 
-    def auth_with_token_async(self, token, app_token=None, **kwargs):
+    def auth_with_token_async(self, token, **kwargs):
         """Authenticate to the robot using a previously created user token.
 
         See auth_with_token documentation for more details.
         """
-        req = _build_auth_token_request(token, app_token)
+        req = _build_auth_token_request(token)
         return self.call_async(self._stub.GetAuthToken, req, _token_from_response,
                                _error_from_response, copy_request=False, **kwargs)

bosdyn/client/autowalk.py

@@ -41,6 +41,7 @@ class AutowalkClient(BaseClient):
 
     def update_from(self, other):
         """Update instance from another object.
+
         Args:
             other: The object where to copy from.
         """
@@ -50,6 +51,7 @@ class AutowalkClient(BaseClient):
 
     def compile_autowalk(self, walk, data_chunk_byte_size=1000 * 1000, **kwargs):
         """Send the input walk file to the autowalk service for compilation.
+
         Args:
             walk: a walks_pb2.Walk input to be compiled by the autowalk service
             data_chunk_byte_size: max size of each streamed message
@@ -69,6 +71,7 @@ class AutowalkClient(BaseClient):
     def load_autowalk(self, walk, leases=[], data_chunk_byte_size=1000 * 1000, **kwargs):
         """Send the input walk file to the autowalk service for compilation and
         load resulting mission to the Mission Service on the robot.
+
         Args:
             walk: a walks_pb2.Walk input to be loaded onto the robot by the autowalk service
             leases: Leases the autowalk service will need to use. Unlike other clients, these MUST

bosdyn/client/channel.py

@@ -9,53 +9,47 @@ import warnings
 
 import grpc
 
-from .exceptions import (ClientCancelledOperationError, InvalidAppTokenError,
-                         InvalidClientCertificateError, NonexistentAuthorityError, NotFoundError,
-                         PermissionDeniedError, ProxyConnectionError, ResponseTooLargeError,
-                         RetryableUnavailableError, RpcError, ServiceFailedDuringExecutionError,
-                         ServiceUnavailableError, TimedOutError, TooManyRequestsError,
-                         TransientFailureError, UnableToConnectToRobotError, UnauthenticatedError,
-                         UnimplementedError, UnknownDnsNameError)
+from .exceptions import (ClientCancelledOperationError, InvalidClientCertificateError,
+                         NonexistentAuthorityError, NotFoundError, PermissionDeniedError,
+                         ProxyConnectionError, ResponseTooLargeError, RetryableUnavailableError,
+                         RpcError, ServiceFailedDuringExecutionError, ServiceUnavailableError,
+                         TimedOutError, TooManyRequestsError, TransientFailureError,
+                         UnableToConnectToRobotError, UnauthenticatedError, UnimplementedError,
+                         UnknownDnsNameError)
 
 TransportError = grpc.RpcError
 
 _LOGGER = logging.getLogger(__name__)
 
-# Set default max message length for sending and receiving to 100MB. This value is used when
+# Set default max message length for sending and receiving. This value is used when
 # creating channels in the bosdyn.client.Robot class.
 DEFAULT_MAX_MESSAGE_LENGTH = 100 * (1024**2)
 
+# Period in milliseconds after which a keepalive ping is sent on the transport.
+DEFAULT_KEEP_ALIVE_TIME_MS = 5000
+
 
 class RefreshingAccessTokenAuthMetadataPlugin(grpc.AuthMetadataPlugin):
     """Plugin to refresh access token.
 
     Args:
-        token_cb: Callable that returns a tuple of (app_token, user_token)
-        add_app_token (bool): Deprecated
+        token_cb: a callback to provide a valid user token.
     """
 
-    def __init__(self, token_cb, add_app_token=None):
+    def __init__(self, token_cb):
         self._token_cb = token_cb
-        if add_app_token is not None:
-            warnings.warn(
-                'add_app_token is deprecated for RefreshingAccessTokenAuthMetadataPlugin. '
-                'Do not set it', DeprecationWarning)
 
     def __call__(self, context, callback):
-        app_token, user_token = self._token_cb()
-        user_token_metadata = ('authorization', 'Bearer {}'.format(user_token))
+        user_token_metadata = ('authorization', 'Bearer {}'.format(self._token_cb()))
         metadata = (user_token_metadata,)
         error = None
         callback(metadata, error)
 
 
-def create_secure_channel_creds(cert, token_cb, add_app_token=None):
+def create_secure_channel_creds(cert, token_cb):
     """Returns credentials for establishing a secure channel.
     Uses previously set values on the linked Sdk and self.
     """
-    if add_app_token is not None:
-        warnings.warn('add_app_token is deprecated for create_secure_channel_creds. Do not set it.',
-                      DeprecationWarning)
 
     transport_creds = grpc.ssl_channel_credentials(root_certificates=cert)
     plugin = RefreshingAccessTokenAuthMetadataPlugin(token_cb)
@@ -126,8 +120,6 @@ def translate_exception(rpc_error):
     if code is grpc.StatusCode.CANCELLED:
         if str(401) in details:
             return UnauthenticatedError(rpc_error, UnauthenticatedError.__doc__)
-        elif str(403) in details:
-            return InvalidAppTokenError(rpc_error, InvalidAppTokenError.__doc__)
         elif str(404) in details:
             return NotFoundError(rpc_error, NotFoundError.__doc__)
         elif str(429) in details:
@@ -183,15 +175,19 @@ def translate_exception(rpc_error):
     return RpcError(rpc_error, RpcError.__doc__)
 
 
-def generate_channel_options(max_send_message_length=None, max_receive_message_length=None):
+def generate_channel_options(max_send_message_length=None, max_receive_message_length=None,
+                             keep_alive_ping_time_ms=None):
     """Generate the array of options to specify in the creation of a client channel or server.
 
     The list contains the values for max allowed message length for both sending and
-    receiving. If no values are provided, the default values of 100 MB are used.
+    receiving. If no values are provided, the default values of 100 MB are used. It also contains a
+    value for time between keep_alive pings, which default to 5s.
 
     Args:
         max_send_message_length (int): Max message length allowed for message to send.
         max_receive_message_length (int):  Max message length allowed for message to receive.
+        keep_alive_ping_time_ms (int):  Period in milliseconds after which a keepalive ping is sent
+        on the transport.
 
     Returns:
         Array with values for channel options.
@@ -199,4 +195,5 @@ def generate_channel_options(max_send_message_length=None, max_receive_message_l
 
     return [('grpc.max_send_message_length', max_send_message_length or DEFAULT_MAX_MESSAGE_LENGTH),
             ('grpc.max_receive_message_length', max_receive_message_length or
-             DEFAULT_MAX_MESSAGE_LENGTH)]
+             DEFAULT_MAX_MESSAGE_LENGTH),
+            ('grpc.keepalive_time_ms', keep_alive_ping_time_ms or DEFAULT_KEEP_ALIVE_TIME_MS)]