standardbots 2.20240723.13__tar.gz → 2.20240924.1__tar.gz

{standardbots-2.20240723.13 → standardbots-2.20240924.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: standardbots
-Version: 2.20240723.13
+Version: 2.20240924.1
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.20240723.13 → standardbots-2.20240924.1}/setup.py

@@ -13,7 +13,7 @@
 from setuptools import setup, find_packages  # noqa: H301
 
 NAME = "standardbots"
-VERSION = "2.20240723.13"
+VERSION = "2.20240924.1"
 # To install the library, run the following
 #
 # python setup.py install

{standardbots-2.20240723.13 → standardbots-2.20240924.1}/standardbots/auto_generated/__init__.py

@@ -1,3 +1,4 @@
 from . import models
 from . import apis
 from .apis import StandardBotsRobot
+from .models import *

{standardbots-2.20240723.13 → standardbots-2.20240924.1}/standardbots/auto_generated/apis.py

@@ -663,11 +663,12 @@ class Camera:
       """
       Retrieve the latest RGB frame from the camera.
       """
-      path = "/api/v1/camera/stream"
+      path = "/api/v1/camera/stream/rgb"
       response = self._request_manager.request(
         "GET",
         path,
         headers=self._request_manager.json_headers(),
+        preload_content=False,
       )
       parsed = None
 
@@ -725,6 +726,56 @@ class Camera:
     self.data = Camera.Data(request_manager)
     self.settings = Camera.Settings(request_manager)
 
+class Faults:
+  _request_manager: RequestManager
+  class UserFaults:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def trigger_user_fault(
+      self,
+      body: models.TriggerFaultRequest,
+    ) -> Response[
+      Union[
+        models.ErrorResponse,
+        models.ErrorResponse,
+        None
+      ],
+      None
+    ]:
+      """
+      Trigger user faults for routine
+
+      """
+      path = "/api/v1/faults/user-fault"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_trigger_fault_request(body)),
+      )
+      parsed = None
+      if response.status == 400:
+        parsed = models.parse_error_response(json.loads(response.data))
+
+      is_user_error = response.status >= 400 and response.status < 500
+      is_unavailable = response.status == 503
+      if parsed is None and (is_user_error or is_unavailable):
+        parsed = models.parse_error_response(json.loads(response.data))
+
+      return Response(
+        parsed,
+        response.status,
+        response
+      )
+
+  user_faults: UserFaults
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = request_manager
+    self.user_faults = Faults.UserFaults(request_manager)
+
 class ChatGPT:
   _request_manager: RequestManager
   class Data:
@@ -949,11 +1000,12 @@ class Recovery:
       self,
     ) -> Response[
       Union[
+        models.RecoveryStatusResponse,
         models.ErrorResponse,
         models.ErrorResponse,
         None
       ],
-      None
+      models.RecoveryStatusResponse
     ]:
       """
       Recovers the robot from a fault state.
@@ -966,6 +1018,8 @@ class Recovery:
         headers=self._request_manager.json_headers(),
       )
       parsed = None
+      if response.status == 200:
+        parsed = models.parse_recovery_status_response(json.loads(response.data))
       if response.status == 400:
         parsed = models.parse_error_response(json.loads(response.data))
 
@@ -1460,90 +1514,6 @@ class Status:
     self.control = Status.Control(request_manager)
     self.health = Status.Health(request_manager)
 
-class Teleoperation:
-  _request_manager: RequestManager
-  class Control:
-    def __init__(self, request_manager: RequestManager):
-      self._request_manager = request_manager
-
-
-    def update_teleop_state(
-      self,
-      body: models.TeleopStateUpdateRequest,
-    ) -> Response[
-      Union[
-        models.TeleopStateResponse,
-        models.ErrorResponse,
-        None
-      ],
-      models.TeleopStateResponse
-    ]:
-      """
-      Updates the state of teleoperation based on the provided action (&#x27;start&#x27; or &#x27;stop&#x27;).
-      """
-      path = "/api/v1/movement/teleop/state"
-      response = self._request_manager.request(
-        "POST",
-        path,
-        headers=self._request_manager.json_headers(),
-        body=json.dumps(models.serialize_teleop_state_update_request(body)),
-      )
-      parsed = None
-      if response.status == 200:
-        parsed = models.parse_teleop_state_response(json.loads(response.data))
-
-      is_user_error = response.status >= 400 and response.status < 500
-      is_unavailable = response.status == 503
-      if parsed is None and (is_user_error or is_unavailable):
-        parsed = models.parse_error_response(json.loads(response.data))
-
-      return Response(
-        parsed,
-        response.status,
-        response
-      )
-
-  class Status:
-    def __init__(self, request_manager: RequestManager):
-      self._request_manager = request_manager
-
-
-    def get_teleop_state(
-      self,
-    ) -> Response[
-      None,
-      None
-    ]:
-      """
-      Retrieves the current state of teleoperation.
-      """
-      path = "/api/v1/movement/teleop/state"
-      response = self._request_manager.request(
-        "GET",
-        path,
-        headers=self._request_manager.json_headers(),
-      )
-      parsed = None
-
-      is_user_error = response.status >= 400 and response.status < 500
-      is_unavailable = response.status == 503
-      if parsed is None and (is_user_error or is_unavailable):
-        parsed = models.parse_error_response(json.loads(response.data))
-
-      return Response(
-        parsed,
-        response.status,
-        response
-      )
-
-  control: Control
-  status: Status
-
-  def __init__(self, request_manager: RequestManager):
-    self._request_manager = request_manager
-    self.control = Teleoperation.Control(request_manager)
-    self.status = Teleoperation.Status(request_manager)
-
 
 
 
@@ -1552,6 +1522,7 @@ class StandardBotsRobot(Default):
 
   movement: Movement
   camera: Camera
+  faults: Faults
   chat_gpt: ChatGPT
   io: IO
   general: General
@@ -1559,7 +1530,6 @@ class StandardBotsRobot(Default):
   ros: ROS
   routine_editor: RoutineEditor
   status: Status
-  teleoperation: Teleoperation
   def __init__(
     self,
     url: str,
@@ -1575,6 +1545,7 @@ class StandardBotsRobot(Default):
     ))
     self.movement = Movement(self._request_manager)
     self.camera = Camera(self._request_manager)
+    self.faults = Faults(self._request_manager)
     self.chat_gpt = ChatGPT(self._request_manager)
     self.io = IO(self._request_manager)
     self.general = General(self._request_manager)
@@ -1582,7 +1553,6 @@ class StandardBotsRobot(Default):
     self.ros = ROS(self._request_manager)
     self.routine_editor = RoutineEditor(self._request_manager)
     self.status = Status(self._request_manager)
-    self.teleoperation = Teleoperation(self._request_manager)
 
   @contextmanager
   def connection(self):

{standardbots-2.20240723.13 → standardbots-2.20240924.1}/standardbots/auto_generated/models.py

@@ -911,6 +911,8 @@ def serialize_force_unit_kind(data: Union[ForceUnitKind, str]) -> object:
 class GripperKindEnum(Enum):
   Onrobot2Fg7 = "onrobot_2fg7"
   """An OnRobot 2FG7 Gripper is connected"""
+  Onrobot2Fg14 = "onrobot_2fg14"
+  """An OnRobot 2FG14 Gripper is connected"""
   Onrobot3Fg15 = "onrobot_3fg15"
   """An OnRobot 3FG15 Gripper is connected"""
   DhAg = "dh_ag"
@@ -919,6 +921,8 @@ class GripperKindEnum(Enum):
   """A DH PGC Gripper is connected"""
   DhCgi = "dh_cgi"
   """A DH CGI Gripper is connected"""
+  SchunkEgx = "schunk_egx"
+  """A Schunk EGU / EGK Gripper is connected"""
   NoneConnected = "none_connected"
   """No gripper is connected"""
 
@@ -928,64 +932,16 @@ def parse_gripper_kind_enum(data: object) -> GripperKindEnum:
 def serialize_gripper_kind_enum(data: Union[GripperKindEnum, str]) -> object:
   return GripperKindEnum(data).value
 
-@dataclass
-class IOStateResponse:
-  """Response to a query for the current state of I/O."""
-  state: Union[str, None] = None
-
-  def validate_state(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "state must be of type str for IOStateResponse, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_state(self.state)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_io_state_response(data: object):
-  return IOStateResponse(
-    state=parse_str(data["state"]) if "state" in data else None,
-  )
+IOStateMap = Dict[str, str]
 
-def serialize_io_state_response(data: IOStateResponse) -> object:
+def parse_io_state_map(data: object) -> IOStateMap:
   return {
-    "state": None if data.state is None else serialize_str(data.state),
+    parse_str(key): parse_str(value) for key, value in data.items()
   }
 
-@dataclass
-class IOStateUpdateRequest:
-  """Request to update the state of I/O to either start or stop."""
-  state: Union[str, None] = None
-
-  def validate_state(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "state must be of type str for IOStateUpdateRequest, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_state(self.state)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_io_state_update_request(data: object):
-  return IOStateUpdateRequest(
-    state=parse_str(data["state"]) if "state" in data else None,
-  )
-
-def serialize_io_state_update_request(data: IOStateUpdateRequest) -> object:
+def serialize_io_state_map(data: IOStateMap) -> object:
   return {
-    "state": None if data.state is None else serialize_str(data.state),
+    serialize_str(key): serialize_str(value) for key, value in data.items()
   }
 
 JointRotations = Tuple[float,float,float,float,float,float,]
@@ -1026,6 +982,18 @@ def parse_linear_unit_kind(data: object) -> LinearUnitKind:
 def serialize_linear_unit_kind(data: Union[LinearUnitKind, str]) -> object:
   return LinearUnitKind(data).value
 
+class OnRobot2FG14ControlKindEnum(Enum):
+  Move = "move"
+  """Move gripper to target grip width"""
+  ForceGrip = "force_grip"
+  """Grip with target force"""
+
+def parse_on_robot_2_fg_14_control_kind_enum(data: object) -> OnRobot2FG14ControlKindEnum:
+  return OnRobot2FG14ControlKindEnum(data)
+
+def serialize_on_robot_2_fg_14_control_kind_enum(data: Union[OnRobot2FG14ControlKindEnum, str]) -> object:
+  return OnRobot2FG14ControlKindEnum(data).value
+
 class OnRobot2FG7ControlKindEnum(Enum):
   Move = "move"
   """Move gripper to target grip width"""
@@ -1242,6 +1210,70 @@ def serialize_quaternion(data: Quaternion) -> object:
     "w": None if data.w is None else serialize_f_64(data.w),
   }
 
+class RecoveryStateEnum(Enum):
+  Success = "Success"
+  """Enum Success = `Success`"""
+  Interrupted = "Interrupted"
+  """Enum Interrupted = `Interrupted`"""
+  NonIdle = "NonIdle"
+  """Enum NonIdle = `NonIdle`"""
+  Braked = "Braked"
+  """Enum Braked = `Braked`"""
+  PlanningFailure = "PlanningFailure"
+  """Enum PlanningFailure = `PlanningFailure`"""
+  ExecutionFailure = "ExecutionFailure"
+  """Enum ExecutionFailure = `ExecutionFailure`"""
+  ControlSystemFailure = "ControlSystemFailure"
+  """Enum ControlSystemFailure = `ControlSystemFailure`"""
+  EStopTriggered = "EStopTriggered"
+  """Enum EStopTriggered = `EStopTriggered`"""
+  GripperFailure = "GripperFailure"
+  """Enum GripperFailure = `GripperFailure`"""
+  OutOfJointLimitsFailure = "OutOfJointLimitsFailure"
+  """Enum OutOfJointLimitsFailure = `OutOfJointLimitsFailure`"""
+  CollisionFailure = "CollisionFailure"
+  """Enum CollisionFailure = `CollisionFailure`"""
+  TorqueCollisionFailure = "TorqueCollisionFailure"
+  """Enum TorqueCollisionFailure = `TorqueCollisionFailure`"""
+  InBoxingPositionFailure = "InBoxingPositionFailure"
+  """Enum InBoxingPositionFailure = `InBoxingPositionFailure`"""
+  PowerBoardCheckFailure = "PowerBoardCheckFailure"
+  """Enum PowerBoardCheckFailure = `PowerBoardCheckFailure`"""
+  MotionPlannerFailure = "MotionPlannerFailure"
+  """Enum MotionPlannerFailure = `MotionPlannerFailure`"""
+  MotionPlannerFailureStartPositionCollision = "MotionPlannerFailureStartPositionCollision"
+  """Enum MotionPlannerFailureStartPositionCollision = `MotionPlannerFailureStartPositionCollision`"""
+  IOFailure = "IOFailure"
+  """Enum IOFailure = `IOFailure`"""
+  InvalidRoutineLoadedFailure = "InvalidRoutineLoadedFailure"
+  """Enum InvalidRoutineLoadedFailure = `InvalidRoutineLoadedFailure`"""
+  InferenceFailure = "InferenceFailure"
+  """Enum InferenceFailure = `InferenceFailure`"""
+  CameraFailure = "CameraFailure"
+  """Enum CameraFailure = `CameraFailure`"""
+  HaasFailure = "HaasFailure"
+  """Enum HaasFailure = `HaasFailure`"""
+  BotmanHeartbeatLost = "BotmanHeartbeatLost"
+  """Enum BotmanHeartbeatLost = `BotmanHeartbeatLost`"""
+  InternalFailure = "InternalFailure"
+  """Enum InternalFailure = `InternalFailure`"""
+  TorqueLimitExceeded = "TorqueLimitExceeded"
+  """Enum TorqueLimitExceeded = `TorqueLimitExceeded`"""
+  StepPlayFailure = "StepPlayFailure"
+  """Enum StepPlayFailure = `StepPlayFailure`"""
+  UnbrakeFailure = "UnbrakeFailure"
+  """Enum UnbrakeFailure = `UnbrakeFailure`"""
+  WeldFailure = "WeldFailure"
+  """Enum WeldFailure = `WeldFailure`"""
+  TriggerFaultFailure = "TriggerFaultFailure"
+  """Enum TriggerFaultFailure = `TriggerFaultFailure`"""
+
+def parse_recovery_state_enum(data: object) -> RecoveryStateEnum:
+  return RecoveryStateEnum(data)
+
+def serialize_recovery_state_enum(data: Union[RecoveryStateEnum, str]) -> object:
+  return RecoveryStateEnum(data).value
+
 class RobotControlModeEnum(Enum):
   Api = "api"
   """The robot is controlled via the Standard Bots Robot API (this API)"""
@@ -1308,6 +1340,16 @@ def serialize_runtime_variable(data: RuntimeVariable) -> object:
     "value": None if data.value is None else serialize_str(data.value),
   }
 
+class SchunkEGxControlKindEnum(Enum):
+  Move = "move"
+  """Move gripper to target grip diameter"""
+
+def parse_schunk_e_gx_control_kind_enum(data: object) -> SchunkEGxControlKindEnum:
+  return SchunkEGxControlKindEnum(data)
+
+def serialize_schunk_e_gx_control_kind_enum(data: Union[SchunkEGxControlKindEnum, str]) -> object:
+  return SchunkEGxControlKindEnum(data).value
+
 SkillsList = List[str]
 
 def parse_skills_list(data: object) -> SkillsList:
@@ -1405,54 +1447,50 @@ def serialize_status_version_data(data: StatusVersionData) -> object:
     "name": None if data.name is None else serialize_str(data.name),
   }
 
-class TeleopStateEnum(Enum):
-  WaitForTeleop = "wait_for_teleop"
-  """The system is waiting to start teleoperation."""
-  Teleop = "teleop"
-  """Teleoperation is active, and the robot is being controlled remotely."""
-  Stopping = "stopping"
-  """The robot is stopping."""
-  Stopped = "stopped"
-  """Teleoperation is stopped, and the robot is not moving."""
-  Moving = "moving"
-  """The robot is moving but not under teleoperation."""
-  Unfrozen = "unfrozen"
-  """The mini-arm is unfrozen."""
-
-def parse_teleop_state_enum(data: object) -> TeleopStateEnum:
-  return TeleopStateEnum(data)
-
-def serialize_teleop_state_enum(data: Union[TeleopStateEnum, str]) -> object:
-  return TeleopStateEnum(data).value
-
 @dataclass
-class TeleopStateUpdateRequest:
-  """Request to update the state of teleoperation to either start or stop."""
-  action: Union[str, None] = None
+class TriggerFaultRequest:
+  """Request to trigger an user fault for routine.
+"""
+  message: Union[str, None] = None
+  isRecoverable: Union[bool, None] = None
 
-  def validate_action(self, value: str) -> Tuple[bool, str]:
+  def validate_message(self, value: str) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
 
     if not isinstance(value, str):
-      return [False, "action must be of type str for TeleopStateUpdateRequest, got " + type(value).__name__]
+      return [False, "message must be of type str for TriggerFaultRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_isRecoverable(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "isRecoverable must be of type bool for TriggerFaultRequest, got " + type(value).__name__]
 
     return [True, ""]
 
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_action(self.action)
+    is_valid, error_str = self.validate_message(self.message)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_isRecoverable(self.isRecoverable)
     if not is_valid:
       raise TypeError(error_str)
 
-def parse_teleop_state_update_request(data: object):
-  return TeleopStateUpdateRequest(
-    action=parse_str(data["action"]) if "action" in data else None,
+def parse_trigger_fault_request(data: object):
+  return TriggerFaultRequest(
+    message=parse_str(data["message"]) if "message" in data else None,
+    isRecoverable=parse_bool(data["isRecoverable"]) if "isRecoverable" in data else None,
   )
 
-def serialize_teleop_state_update_request(data: TeleopStateUpdateRequest) -> object:
+def serialize_trigger_fault_request(data: TriggerFaultRequest) -> object:
   return {
-    "action": None if data.action is None else serialize_str(data.action),
+    "message": None if data.message is None else serialize_str(data.message),
+    "isRecoverable": None if data.isRecoverable is None else serialize_bool(data.isRecoverable),
   }
 
 @dataclass
@@ -1800,7 +1838,7 @@ class GripperConfiguration:
     if value is None:
       return [False, "kind is required for GripperConfiguration"]
 
-    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -1863,6 +1901,66 @@ def serialize_gripper_configuration(data: GripperConfiguration) -> object:
     "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_configuration(data.dh_cgi),
   }
 
+@dataclass
+class IOStateResponse:
+  """Response to a query for the current state of I/O."""
+  state: Union[IOStateMap, None] = None
+
+  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "state must be of type IOStateMap for IOStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_io_state_response(data: object):
+  return IOStateResponse(
+    state=parse_io_state_map(data["state"]) if "state" in data else None,
+  )
+
+def serialize_io_state_response(data: IOStateResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_io_state_map(data.state),
+  }
+
+@dataclass
+class IOStateUpdateRequest:
+  """Request to update the state of I/O for multiple ports."""
+  state: Union[IOStateMap, None] = None
+
+  def validate_state(self, value: IOStateMap) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "state must be of type IOStateMap for IOStateUpdateRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_io_state_update_request(data: object):
+  return IOStateUpdateRequest(
+    state=parse_io_state_map(data["state"]) if "state" in data else None,
+  )
+
+def serialize_io_state_update_request(data: IOStateUpdateRequest) -> object:
+  return {
+    "state": None if data.state is None else serialize_io_state_map(data.state),
+  }
+
 @dataclass
 class ArmJointRotations:
   """Rotational positions of arm joints"""
@@ -2067,6 +2165,36 @@ def serialize_orientation(data: Orientation) -> object:
     "quaternion": None if data.quaternion is None else serialize_quaternion(data.quaternion),
   }
 
+@dataclass
+class RecoveryStatusResponse:
+  """Recovery status response"""
+  state: Union[RecoveryStateEnum, None] = None
+
+  def validate_state(self, value: RecoveryStateEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and RecoveryStateEnum in ['Success', 'Interrupted', 'NonIdle', 'Braked', 'PlanningFailure', 'ExecutionFailure', 'ControlSystemFailure', 'EStopTriggered', 'GripperFailure', 'OutOfJointLimitsFailure', 'CollisionFailure', 'TorqueCollisionFailure', 'InBoxingPositionFailure', 'PowerBoardCheckFailure', 'MotionPlannerFailure', 'MotionPlannerFailureStartPositionCollision', 'IOFailure', 'InvalidRoutineLoadedFailure', 'InferenceFailure', 'CameraFailure', 'HaasFailure', 'BotmanHeartbeatLost', 'InternalFailure', 'TorqueLimitExceeded', 'StepPlayFailure', 'UnbrakeFailure', 'WeldFailure', 'TriggerFaultFailure']) or isinstance(value, RecoveryStateEnum)):
+      return [False, "state must be of type RecoveryStateEnum for RecoveryStatusResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_recovery_status_response(data: object):
+  return RecoveryStatusResponse(
+    state=parse_recovery_state_enum(data["state"]) if "state" in data else None,
+  )
+
+def serialize_recovery_status_response(data: RecoveryStatusResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_recovery_state_enum(data.state),
+  }
+
 @dataclass
 class RobotControlMode:
   """Definition of Robot Control State, which tells you which service or system is controlling the Robot"""
@@ -2277,36 +2405,6 @@ def serialize_status_health_response(data: StatusHealthResponse) -> object:
     "build": None if data.build is None else serialize_status_version_data(data.build),
   }
 
-@dataclass
-class TeleopStateResponse:
-  """Response to a query for the current state of teleoperation."""
-  state: Union[TeleopStateEnum, None] = None
-
-  def validate_state(self, value: TeleopStateEnum) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not ((isinstance(value, str) and TeleopStateEnum in ['wait_for_teleop', 'teleop', 'stopping', 'stopped', 'moving', 'unfrozen']) or isinstance(value, TeleopStateEnum)):
-      return [False, "state must be of type TeleopStateEnum for TeleopStateResponse, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def __post_init__(self):
-    # Type check incoming model - raise error if invalid (required or wrong type)
-    is_valid, error_str = self.validate_state(self.state)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_teleop_state_response(data: object):
-  return TeleopStateResponse(
-    state=parse_teleop_state_enum(data["state"]) if "state" in data else None,
-  )
-
-def serialize_teleop_state_response(data: TeleopStateResponse) -> object:
-  return {
-    "state": None if data.state is None else serialize_teleop_state_enum(data.state),
-  }
-
 @dataclass
 class ArmPositionUpdateRequestResponseEventStreamDetails:
   """Specify how the response should be sent
@@ -2511,6 +2609,82 @@ def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
 def serialize_arm_joint_rotations_list(data: ArmJointRotationsList) -> List[object]:
   return [serialize_arm_joint_rotations(item) for item in data]
 
+@dataclass
+class OnRobot2FG14GripperCommandRequest:
+  """Control the OnRobot 2FG14 gripper (end effector) of the robot
+"""
+  grip_direction: Union[LinearGripDirectionEnum, None] = None
+  target_force: Union[ForceUnit, None] = None
+  target_grip_width: Union[LinearUnit, None] = None
+  control_kind: Union[OnRobot2FG14ControlKindEnum, None] = None
+
+  def validate_grip_direction(self, value: LinearGripDirectionEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "grip_direction is required for OnRobot2FG14GripperCommandRequest"]
+
+    if not ((isinstance(value, str) and LinearGripDirectionEnum in ['inward', 'outward']) or isinstance(value, LinearGripDirectionEnum)):
+      return [False, "grip_direction must be of type LinearGripDirectionEnum for OnRobot2FG14GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_force(self, value: ForceUnit) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, ForceUnit):
+      return [False, "target_force must be of type ForceUnit for OnRobot2FG14GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_grip_width(self, value: LinearUnit) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, LinearUnit):
+      return [False, "target_grip_width must be of type LinearUnit for OnRobot2FG14GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_control_kind(self, value: OnRobot2FG14ControlKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "control_kind is required for OnRobot2FG14GripperCommandRequest"]
+
+    if not ((isinstance(value, str) and OnRobot2FG14ControlKindEnum in ['move', 'force_grip']) or isinstance(value, OnRobot2FG14ControlKindEnum)):
+      return [False, "control_kind must be of type OnRobot2FG14ControlKindEnum for OnRobot2FG14GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_grip_direction(self.grip_direction)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_target_force(self.target_force)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_target_grip_width(self.target_grip_width)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_control_kind(self.control_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_on_robot_2_fg_14_gripper_command_request(data: object):
+  return OnRobot2FG14GripperCommandRequest(
+    grip_direction=parse_linear_grip_direction_enum(data["grip_direction"]) if "grip_direction" in data else None,
+    target_force=parse_force_unit(data["target_force"]) if "target_force" in data else None,
+    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data else None,
+    control_kind=parse_on_robot_2_fg_14_control_kind_enum(data["control_kind"]) if "control_kind" in data else None,
+  )
+
+def serialize_on_robot_2_fg_14_gripper_command_request(data: OnRobot2FG14GripperCommandRequest) -> object:
+  return {
+    "grip_direction": serialize_linear_grip_direction_enum(data.grip_direction),
+    "target_force": None if data.target_force is None else serialize_force_unit(data.target_force),
+    "target_grip_width": None if data.target_grip_width is None else serialize_linear_unit(data.target_grip_width),
+    "control_kind": serialize_on_robot_2_fg_14_control_kind_enum(data.control_kind),
+  }
+
 @dataclass
 class OnRobot2FG7GripperCommandRequest:
   """Control the OnRobot 2FG7 gripper (end effector) of the robot
@@ -2663,6 +2837,52 @@ def serialize_on_robot_3_fg_15_gripper_command_request(data: OnRobot3FG15Gripper
     "control_kind": serialize_on_robot_3_fg_15_control_kind_enum(data.control_kind),
   }
 
+@dataclass
+class SchunkEGxGripperCommandRequest:
+  """Control the Schunk EGU / EGK  gripper (end effector) of the robot
+"""
+  target_grip_width: Union[LinearUnit, None] = None
+  control_kind: Union[SchunkEGxControlKindEnum, None] = None
+
+  def validate_target_grip_width(self, value: LinearUnit) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, LinearUnit):
+      return [False, "target_grip_width must be of type LinearUnit for SchunkEGxGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_control_kind(self, value: SchunkEGxControlKindEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "control_kind is required for SchunkEGxGripperCommandRequest"]
+
+    if not ((isinstance(value, str) and SchunkEGxControlKindEnum in ['move']) or isinstance(value, SchunkEGxControlKindEnum)):
+      return [False, "control_kind must be of type SchunkEGxControlKindEnum for SchunkEGxGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_target_grip_width(self.target_grip_width)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_control_kind(self.control_kind)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_schunk_e_gx_gripper_command_request(data: object):
+  return SchunkEGxGripperCommandRequest(
+    target_grip_width=parse_linear_unit(data["target_grip_width"]) if "target_grip_width" in data else None,
+    control_kind=parse_schunk_e_gx_control_kind_enum(data["control_kind"]) if "control_kind" in data else None,
+  )
+
+def serialize_schunk_e_gx_gripper_command_request(data: SchunkEGxGripperCommandRequest) -> object:
+  return {
+    "target_grip_width": None if data.target_grip_width is None else serialize_linear_unit(data.target_grip_width),
+    "control_kind": serialize_schunk_e_gx_control_kind_enum(data.control_kind),
+  }
+
 @dataclass
 class PlanesPaginatedResponse:
   """Paginated response containing plane data"""
@@ -2843,16 +3063,18 @@ class GripperCommandRequest:
 """
   kind: Union[GripperKindEnum, None] = None
   onrobot_2fg7: Union[OnRobot2FG7GripperCommandRequest, None] = None
+  onrobot_2fg14: Union[OnRobot2FG14GripperCommandRequest, None] = None
   onrobot_3fg15: Union[OnRobot3FG15GripperCommandRequest, None] = None
   dh_ag: Union[DHAGGripperCommandRequest, None] = None
   dh_pgc: Union[DHPGCGripperCommandRequest, None] = None
   dh_cgi: Union[DHCGIGripperCommandRequest, None] = None
+  schunk_egx: Union[SchunkEGxGripperCommandRequest, None] = None
 
   def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
     if value is None:
       return [False, "kind is required for GripperCommandRequest"]
 
-    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_2fg14', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'schunk_egx', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -2866,6 +3088,15 @@ class GripperCommandRequest:
 
     return [True, ""]
 
+  def validate_onrobot_2fg14(self, value: OnRobot2FG14GripperCommandRequest) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, OnRobot2FG14GripperCommandRequest):
+      return [False, "onrobot_2fg14 must be of type OnRobot2FG14GripperCommandRequest for GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
   def validate_onrobot_3fg15(self, value: OnRobot3FG15GripperCommandRequest) -> Tuple[bool, str]:
     if value is None:
       return [True, ""]
@@ -2902,12 +3133,24 @@ class GripperCommandRequest:
 
     return [True, ""]
 
+  def validate_schunk_egx(self, value: SchunkEGxGripperCommandRequest) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, SchunkEGxGripperCommandRequest):
+      return [False, "schunk_egx must be of type SchunkEGxGripperCommandRequest for GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
     is_valid, error_str = self.validate_kind(self.kind)
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_onrobot_2fg7(self.onrobot_2fg7)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_onrobot_2fg14(self.onrobot_2fg14)
     if not is_valid:
       raise TypeError(error_str)
     is_valid, error_str = self.validate_onrobot_3fg15(self.onrobot_3fg15)
@@ -2922,25 +3165,32 @@ class GripperCommandRequest:
     is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_schunk_egx(self.schunk_egx)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_gripper_command_request(data: object):
   return GripperCommandRequest(
     kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data else None,
     onrobot_2fg7=parse_on_robot_2_fg_7_gripper_command_request(data["onrobot_2fg7"]) if "onrobot_2fg7" in data else None,
+    onrobot_2fg14=parse_on_robot_2_fg_14_gripper_command_request(data["onrobot_2fg14"]) if "onrobot_2fg14" in data else None,
     onrobot_3fg15=parse_on_robot_3_fg_15_gripper_command_request(data["onrobot_3fg15"]) if "onrobot_3fg15" in data else None,
     dh_ag=parse_dhag_gripper_command_request(data["dh_ag"]) if "dh_ag" in data else None,
     dh_pgc=parse_dhpgc_gripper_command_request(data["dh_pgc"]) if "dh_pgc" in data else None,
     dh_cgi=parse_dhcgi_gripper_command_request(data["dh_cgi"]) if "dh_cgi" in data else None,
+    schunk_egx=parse_schunk_e_gx_gripper_command_request(data["schunk_egx"]) if "schunk_egx" in data else None,
   )
 
 def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
   return {
     "kind": serialize_gripper_kind_enum(data.kind),
     "onrobot_2fg7": None if data.onrobot_2fg7 is None else serialize_on_robot_2_fg_7_gripper_command_request(data.onrobot_2fg7),
+    "onrobot_2fg14": None if data.onrobot_2fg14 is None else serialize_on_robot_2_fg_14_gripper_command_request(data.onrobot_2fg14),
     "onrobot_3fg15": None if data.onrobot_3fg15 is None else serialize_on_robot_3_fg_15_gripper_command_request(data.onrobot_3fg15),
     "dh_ag": None if data.dh_ag is None else serialize_dhag_gripper_command_request(data.dh_ag),
     "dh_pgc": None if data.dh_pgc is None else serialize_dhpgc_gripper_command_request(data.dh_pgc),
     "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_command_request(data.dh_cgi),
+    "schunk_egx": None if data.schunk_egx is None else serialize_schunk_e_gx_gripper_command_request(data.schunk_egx),
   }
 
 @dataclass

{standardbots-2.20240723.13 → standardbots-2.20240924.1}/standardbots.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: standardbots
-Version: 2.20240723.13
+Version: 2.20240924.1
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support