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

bosdyn/client/power.py

@@ -67,8 +67,16 @@ class FanControlTemperatureError(PowerResponseError):
     """Current measured robot temperatures are too high to accept user fan command."""
 
 
+class SafetyStopIncompatibleHardwareError(PowerResponseError):
+    """SafetyStop command invalid because robot is not configured for SRSF."""
 
 
+class SafetyStopFailedError(PowerResponseError):
+    """SafetyStop command executed and failed."""
+
+
+class SafetyStopUnknownStopTypeError(PowerResponseError):
+    """SafetyStop command failed due to unknown stop type."""
 
 
 class PowerClient(BaseClient):
@@ -136,7 +144,17 @@ class PowerClient(BaseClient):
         return self.call_async(self._stub.FanPowerCommandFeedback, req, None,
                                _fan_power_feedback_error_from_response, **kwargs)
 
+    def reset_safety_stop(self, safety_stop_type, lease=None, **kwargs):
+        """Issue a reset safety stop request to the robot."""
+        req = self._reset_safety_stop_request(lease, safety_stop_type)
+        return self.call(self._stub.ResetSafetyStop, req, None,
+                         _reset_safety_stop_error_from_response, **kwargs)
 
+    def reset_safety_stop_async(self, safety_stop_type, lease=None, **kwargs):
+        """Async version of reset_safety_stop()"""
+        req = self._reset_safety_stop_request(lease, safety_stop_type)
+        return self.call_async(self._stub.ResetSafetyStop, req, None,
+                               _reset_safety_stop_error_from_response, **kwargs)
 
     @staticmethod
     def _power_command_request(lease, request):
@@ -155,6 +173,9 @@ class PowerClient(BaseClient):
     def _fan_power_command_feedback_request(command_id):
         return power_pb2.FanPowerCommandFeedbackRequest(command_id=command_id)
 
+    @staticmethod
+    def _reset_safety_stop_request(lease, safety_stop_type):
+        return power_pb2.ResetSafetyStopRequest(lease=lease, safety_stop_type=safety_stop_type)
 
 
 def _handle_license_errors(func):
@@ -247,6 +268,25 @@ def _fan_power_feedback_error_from_response(response):
     return None
 
 
+@handle_common_header_errors
+@handle_lease_use_result_errors
+@handle_unset_status_error(unset='STATUS_UNKNOWN', statustype=power_pb2.ResetSafetyStopResponse)
+def _reset_safety_stop_error_from_response(response):
+    return error_factory(response, response.status,
+                         status_to_string=power_pb2.ResetSafetyStopResponse.Status.Name,
+                         status_to_error=_RESET_SAFETY_STOP_STATUS_TO_ERROR)
+
+
+_RESET_SAFETY_STOP_STATUS_TO_ERROR = collections.defaultdict(lambda: (ResponseError, None))
+_RESET_SAFETY_STOP_STATUS_TO_ERROR.update({
+    power_pb2.ResetSafetyStopResponse.STATUS_OK: (None, None),
+    power_pb2.ResetSafetyStopResponse.STATUS_INCOMPATIBLE_HARDWARE_ERROR:
+        (SafetyStopIncompatibleHardwareError, SafetyStopIncompatibleHardwareError.__doc__),
+    power_pb2.ResetSafetyStopResponse.STATUS_FAILED:
+        (SafetyStopFailedError, SafetyStopFailedError.__doc__),
+    power_pb2.ResetSafetyStopResponse.STATUS_UNKNOWN_STOP_TYPE:
+        (SafetyStopUnknownStopTypeError, SafetyStopUnknownStopTypeError.__doc__)
+})
 
 
 @deprecated(reason='Replaced by the less ambiguous safe_power_off_motors function.',

bosdyn/client/recording.py

@@ -158,7 +158,7 @@ class GraphNavRecordingServiceClient(BaseClient):
                                **kwargs)
 
     def create_edge(self, lease=None, edge=None, **kwargs):
-        """Create a edge in the map between two existing waypoints.
+        """Create an edge in the map between two existing waypoints.
 
         Args:
             lease: Leases to show ownership of necessary resources. Will use the client's leases by default.
@@ -276,7 +276,7 @@ class GraphNavRecordingServiceClient(BaseClient):
     def make_edge_environment(
             vel_limit=None, direction_constraint=map_pb2.Edge.Annotations.DIRECTION_CONSTRAINT_NONE,
             require_alignment=False, flat_ground=False, ground_mu_hint=.8, grated_floor=False):
-        """Create a edge environment.
+        """Create an edge environment.
 
         Args:
             vel_limit: A SE2VelocityLimit to use while traversing the edge. Note this is not a target speed, just a max/min.
@@ -373,7 +373,7 @@ class RemoteCloudFailureNoDataError(RecordingServiceResponseError):
 
 
 class NotReadyYetError(RecordingServiceResponseError):
-    """The service is processing the map at it's current position. Try again in 1-2 seconds."""
+    """The service is processing the map at its current position. Try again in 1-2 seconds."""
 
 
 class MapTooLargeLicenseError(RecordingServiceResponseError):

bosdyn/client/robot.py

@@ -8,10 +8,11 @@
 import copy
 import logging
 import time
+from typing import Optional
 
 import bosdyn.api.data_buffer_pb2 as data_buffer_protos
 import bosdyn.client.channel
-from bosdyn.util import timestamp_to_sec
+from bosdyn.util import now_sec, timestamp_to_sec
 
 from .auth import AuthClient
 from .channel import DEFAULT_MAX_MESSAGE_LENGTH
@@ -27,9 +28,9 @@ from .payload_registration import (PayloadAlreadyExistsError, PayloadNotAuthoriz
                                    PayloadRegistrationClient)
 from .power import PowerClient
 from .power import is_powered_on as pkg_is_powered_on
-from .power import power_off as pkg_power_off
-from .power import power_on as pkg_power_on
-from .power import safe_power_off as pkg_safe_power_off
+from .power import power_off_motors as pkg_power_off
+from .power import power_on_motors as pkg_power_on
+from .power import safe_power_off_motors as pkg_safe_power_off
 from .robot_command import RobotCommandClient
 from .robot_id import RobotIdClient
 from .robot_state import RobotStateClient
@@ -125,7 +126,6 @@ class Robot(object):
         self.service_type_by_name = {}
         self.request_processors = []
         self.response_processors = []
-        self.app_token = None
         self.cert = None
         self.lease_wallet = LeaseWallet()
         self._time_sync_thread = None
@@ -261,7 +261,7 @@ class Robot(object):
     def get_cached_hardware_hardware_configuration(self):
         """Return the HardwareConfiguration proto for this robot, querying it from the robot if not
         yet cached.
-        
+
         Raises:
             RpcError: There as a problem communicating with the robot.
         """
@@ -301,10 +301,9 @@ class Robot(object):
         if not authority:
             raise UnregisteredServiceNameError(service_name)
 
-        skip_app_token_check = service_name == 'robot-id'
-        return self.ensure_secure_channel(authority, skip_app_token_check, options=options)
+        return self.ensure_secure_channel(authority, options=options)
 
-    def ensure_secure_channel(self, authority, skip_app_token_check=False, options=[]):
+    def ensure_secure_channel(self, authority, options=[]):
         """Get the channel to access the given authority, creating it if it doesn't exist."""
         if authority in self.channels_by_authority:
             return self.channels_by_authority[authority]
@@ -316,8 +315,8 @@ class Robot(object):
             options.append(('grpc.max_send_message_length', self.max_send_message_length))
 
         # Channel doesn't exist, so create it.
-        creds = bosdyn.client.channel.create_secure_channel_creds(
-            self.cert, lambda: (self.app_token, self.user_token))
+        creds = bosdyn.client.channel.create_secure_channel_creds(self.cert,
+                                                                  lambda: self.user_token)
         channel = bosdyn.client.channel.create_secure_channel(self.address,
                                                               self._secure_channel_port, creds,
                                                               authority, options=options)
@@ -346,7 +345,7 @@ class Robot(object):
         auth_channel = self.ensure_secure_channel(
             Robot._bootstrap_service_authorities[AuthClient.default_service_name])
         auth_client = self.ensure_client(AuthClient.default_service_name, auth_channel)
-        user_token = auth_client.auth(username, password, self.app_token, timeout=timeout)
+        user_token = auth_client.auth(username, password, timeout=timeout)
 
         self.update_user_token(user_token, username)
 
@@ -362,7 +361,7 @@ class Robot(object):
         # We cannot use the directory for the auth service until we are authenticated, so hard-code
         # the authority name.
         auth_client = self.ensure_client(AuthClient.default_service_name)
-        user_token = auth_client.auth_with_token(token, self.app_token, timeout=timeout)
+        user_token = auth_client.auth_with_token(token, timeout=timeout)
 
         self.update_user_token(user_token)
 
@@ -379,7 +378,7 @@ class Robot(object):
         # We cannot use the directory for the auth service until we are authenticated, so hard-code
         # the authority name.
         auth_client = self.ensure_client(AuthClient.default_service_name)
-        user_token = auth_client.auth_with_token(token, self.app_token, timeout=timeout)
+        user_token = auth_client.auth_with_token(token, timeout=timeout)
 
         self.update_user_token(user_token, username)
 
@@ -519,7 +518,7 @@ class Robot(object):
         Returns:
             double: Current robot time, seconds.
         """
-        robot_timestamp = self.time_sync.robot_timestamp_from_local_secs(time.time())
+        robot_timestamp = self.time_sync.robot_timestamp_from_local_secs(now_sec())
         return timestamp_to_sec(robot_timestamp)
 
     def operator_comment(self, comment, timestamp_secs=None, timeout=None):
@@ -542,7 +541,7 @@ class Robot(object):
         client = self.ensure_client(DataBufferClient.default_service_name)
         if timestamp_secs is None:
             try:
-                robot_timestamp = self.time_sync.robot_timestamp_from_local_secs(time.time())
+                robot_timestamp = self.time_sync.robot_timestamp_from_local_secs(now_sec())
             except TimeSyncError:
                 robot_timestamp = None  # Timestamp will be set when robot receives the request msg.
         else: