standardbots 2.20240401.11__tar.gz → 2.20240614.1__tar.gz

{standardbots-2.20240401.11 → standardbots-2.20240614.1}/PKG-INFO

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

{standardbots-2.20240401.11 → standardbots-2.20240614.1}/setup.py

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

{standardbots-2.20240401.11 → standardbots-2.20240614.1}/standardbots/auto_generated/apis.py

@@ -138,6 +138,48 @@ class Default:
                 ),
             ),
         )
+    def dh_pgc_grip(
+        self,
+        target_diameter: float,
+        target_force: float | None,
+        target_speed: float | None,
+    ):
+        """
+        Control the DH PGC gripper.
+        Args:
+        - target_diameter: 0.0 - 1.0
+        - target_force: 0.2 - 1.0
+        - target_speed: 0.01 - 1.0
+        """
+        return self.control_gripper(
+            body=models.GripperCommandRequest(
+                kind=models.GripperKindEnum.DhPgc,
+                dh_pgc=models.DHPGCGripperCommandRequest(
+                    target_diameter, target_force, target_speed
+                ),
+            ),
+        )
+    def dh_cgi_grip(
+        self,
+        target_diameter: float,
+        target_force: float | None,
+        target_speed: float | None,
+    ):
+        """
+        Control the DH CGI gripper.
+        Args:
+        - target_diameter: 0.0 - 1.0
+        - target_force: 0.2 - 1.0
+        - target_speed: 0.01 - 1.0
+        """
+        return self.control_gripper(
+            body=models.GripperCommandRequest(
+                kind=models.GripperKindEnum.DhCgi,
+                dh_pgc=models.DHCGIGripperCommandRequest(
+                    target_diameter, target_force, target_speed
+                ),
+            ),
+        )
     
 
     def control_gripper(
@@ -683,7 +725,7 @@ class Camera:
     self.data = Camera.Data(request_manager)
     self.settings = Camera.Settings(request_manager)
 
-class ChatGpt:
+class ChatGPT:
   _request_manager: RequestManager
   class Data:
     def __init__(self, request_manager: RequestManager):
@@ -754,7 +796,285 @@ class ChatGpt:
 
   def __init__(self, request_manager: RequestManager):
     self._request_manager = request_manager
-    self.data = ChatGpt.Data(request_manager)
+    self.data = ChatGPT.Data(request_manager)
+
+class IO:
+  _request_manager: RequestManager
+  class Control:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def update_io_state(
+      self,
+      body: models.IOStateUpdateRequest,
+    ) -> Response[
+      Union[
+        models.IOStateResponse,
+        models.ErrorResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.IOStateResponse
+    ]:
+      """
+      Updates the state of I/O based on the provided action ('high' or 'low').
+      """
+      path = "/api/v1/io"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_io_state_update_request(body)),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_io_state_response(json.loads(response.data))
+      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
+      )
+
+  class Status:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def get_io_state(
+      self,
+    ) -> Response[
+      Union[
+        models.IOStateResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.IOStateResponse
+    ]:
+      """
+      Retrieves the current state of I/O.
+      """
+      path = "/api/v1/io"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_io_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
+      )
+
+  control: Control
+  status: Status
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = request_manager
+    self.control = IO.Control(request_manager)
+    self.status = IO.Status(request_manager)
+
+class General:
+  _request_manager: RequestManager
+  class Joints:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def get_joints_state(
+      self,
+    ) -> Response[
+      Union[
+        models.JointsStateResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.JointsStateResponse
+    ]:
+      """
+      Retrieves information about the state of each joint
+      """
+      path = "/api/v1/joints"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_joints_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
+      )
+
+  joints: Joints
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = request_manager
+    self.joints = General.Joints(request_manager)
+
+class Recovery:
+  _request_manager: RequestManager
+  class Recover:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def recover(
+      self,
+    ) -> Response[
+      Union[
+        models.ErrorResponse,
+        models.ErrorResponse,
+        None
+      ],
+      None
+    ]:
+      """
+      Recovers the robot from a fault state.
+
+      """
+      path = "/api/v1/recovery/recover"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      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
+      )
+
+  recover: Recover
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = request_manager
+    self.recover = Recovery.Recover(request_manager)
+
+class ROS:
+  _request_manager: RequestManager
+  class Control:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def update_ros_control_state(
+      self,
+      body: models.ROSControlUpdateRequest,
+    ) -> Response[
+      Union[
+        models.ROSControlStateResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.ROSControlStateResponse
+    ]:
+      """
+      Updates the state of ROS control based on the provided action (&#x27;enable&#x27; or &#x27;disable&#x27;).
+      """
+      path = "/api/v1/movement/ros/state"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_ros_control_update_request(body)),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_ros_control_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_ros_control_state(
+      self,
+    ) -> Response[
+      Union[
+        models.ROSControlStateResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.ROSControlStateResponse
+    ]:
+      """
+      Retrieves the current state of ROS control.
+      """
+      path = "/api/v1/movement/ros/state"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_ros_control_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
+      )
+
+  control: Control
+  status: Status
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = request_manager
+    self.control = ROS.Control(request_manager)
+    self.status = ROS.Status(request_manager)
 
 class RoutineEditor:
   _request_manager: RequestManager
@@ -1232,7 +1552,11 @@ class StandardBotsRobot(Default):
 
   movement: Movement
   camera: Camera
-  chat_gpt: ChatGpt
+  chat_gpt: ChatGPT
+  io: IO
+  general: General
+  recovery: Recovery
+  ros: ROS
   routine_editor: RoutineEditor
   status: Status
   teleoperation: Teleoperation
@@ -1251,7 +1575,11 @@ class StandardBotsRobot(Default):
     ))
     self.movement = Movement(self._request_manager)
     self.camera = Camera(self._request_manager)
-    self.chat_gpt = ChatGpt(self._request_manager)
+    self.chat_gpt = ChatGPT(self._request_manager)
+    self.io = IO(self._request_manager)
+    self.general = General(self._request_manager)
+    self.recovery = Recovery(self._request_manager)
+    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)

{standardbots-2.20240401.11 → standardbots-2.20240614.1}/standardbots/auto_generated/models.py

@@ -476,6 +476,20 @@ def serialize_camera_settings(data: CameraSettings) -> object:
     "autoWhiteBalance": None if data.autoWhiteBalance is None else serialize_bool(data.autoWhiteBalance),
   }
 
+class ConnectionStatus(Enum):
+  Connected = "connected"
+  """Enum Connected = `connected`"""
+  Disconnected = "disconnected"
+  """Enum Disconnected = `disconnected`"""
+  Ready = "ready"
+  """Enum Ready = `ready`"""
+
+def parse_connection_status(data: object) -> ConnectionStatus:
+  return ConnectionStatus(data)
+
+def serialize_connection_status(data: Union[ConnectionStatus, str]) -> object:
+  return ConnectionStatus(data).value
+
 @dataclass
 class DHAGGripperCommandRequest:
   """Control the DH AG gripper (end effector) of the robot
@@ -567,6 +581,188 @@ def serialize_dhag_gripper_configuration(data: DHAGGripperConfiguration) -> obje
     "diameter": serialize_f_64(data.diameter),
   }
 
+@dataclass
+class DHCGIGripperCommandRequest:
+  """Control the DH CGI gripper (end effector) of the robot
+"""
+  target_diameter: Union[float, None] = None
+  target_force: Union[float, None] = None
+  target_speed: Union[float, None] = None
+
+  def validate_target_diameter(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "target_diameter is required for DHCGIGripperCommandRequest"]
+
+    if not isinstance(value, float):
+      return [False, "target_diameter must be of type float for DHCGIGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_force(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_force must be of type float for DHCGIGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_speed(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_speed must be of type float for DHCGIGripperCommandRequest, 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_diameter(self.target_diameter)
+    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_speed(self.target_speed)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_dhcgi_gripper_command_request(data: object):
+  return DHCGIGripperCommandRequest(
+    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data else None,
+    target_force=parse_f_64(data["target_force"]) if "target_force" in data else None,
+    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data else None,
+  )
+
+def serialize_dhcgi_gripper_command_request(data: DHCGIGripperCommandRequest) -> object:
+  return {
+    "target_diameter": serialize_f_64(data.target_diameter),
+    "target_force": None if data.target_force is None else serialize_f_64(data.target_force),
+    "target_speed": None if data.target_speed is None else serialize_f_64(data.target_speed),
+  }
+
+@dataclass
+class DHCGIGripperConfiguration:
+  """Configuration for DH CGI Gripper"""
+  diameter: Union[float, None] = None
+
+  def validate_diameter(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "diameter is required for DHCGIGripperConfiguration"]
+
+    if not isinstance(value, float):
+      return [False, "diameter must be of type float for DHCGIGripperConfiguration, 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_diameter(self.diameter)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_dhcgi_gripper_configuration(data: object):
+  return DHCGIGripperConfiguration(
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
+  )
+
+def serialize_dhcgi_gripper_configuration(data: DHCGIGripperConfiguration) -> object:
+  return {
+    "diameter": serialize_f_64(data.diameter),
+  }
+
+@dataclass
+class DHPGCGripperCommandRequest:
+  """Control the DH PGC gripper (end effector) of the robot
+"""
+  target_diameter: Union[float, None] = None
+  target_force: Union[float, None] = None
+  target_speed: Union[float, None] = None
+
+  def validate_target_diameter(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "target_diameter is required for DHPGCGripperCommandRequest"]
+
+    if not isinstance(value, float):
+      return [False, "target_diameter must be of type float for DHPGCGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_force(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_force must be of type float for DHPGCGripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_target_speed(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "target_speed must be of type float for DHPGCGripperCommandRequest, 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_diameter(self.target_diameter)
+    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_speed(self.target_speed)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_dhpgc_gripper_command_request(data: object):
+  return DHPGCGripperCommandRequest(
+    target_diameter=parse_f_64(data["target_diameter"]) if "target_diameter" in data else None,
+    target_force=parse_f_64(data["target_force"]) if "target_force" in data else None,
+    target_speed=parse_f_64(data["target_speed"]) if "target_speed" in data else None,
+  )
+
+def serialize_dhpgc_gripper_command_request(data: DHPGCGripperCommandRequest) -> object:
+  return {
+    "target_diameter": serialize_f_64(data.target_diameter),
+    "target_force": None if data.target_force is None else serialize_f_64(data.target_force),
+    "target_speed": None if data.target_speed is None else serialize_f_64(data.target_speed),
+  }
+
+@dataclass
+class DHPGCGripperConfiguration:
+  """Configuration for DH PGC Gripper"""
+  diameter: Union[float, None] = None
+
+  def validate_diameter(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "diameter is required for DHPGCGripperConfiguration"]
+
+    if not isinstance(value, float):
+      return [False, "diameter must be of type float for DHPGCGripperConfiguration, 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_diameter(self.diameter)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_dhpgc_gripper_configuration(data: object):
+  return DHPGCGripperConfiguration(
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
+  )
+
+def serialize_dhpgc_gripper_configuration(data: DHPGCGripperConfiguration) -> object:
+  return {
+    "diameter": serialize_f_64(data.diameter),
+  }
+
 @dataclass
 class EngageEmergencyStopRequest:
   """Engage Emergency Stop. This will immediately stop the robot and prevent it from moving until the robot is unbraked.
@@ -671,6 +867,8 @@ class ErrorEnum(Enum):
   """Robot brakes engage failed"""
   RequestFailedValidation = "request_failed_validation"
   """Request failed validation"""
+  RobotNotIdle = "robot_not_idle"
+  """Robot must be idle"""
   BrakesMustBeEngaged = "brakes_must_be_engaged"
   """Brakes must be_engaged"""
   BrakesMustBeDisengaged = "brakes_must_be_disengaged"
@@ -687,6 +885,8 @@ class ErrorEnum(Enum):
   """Camera settings timed out"""
   InternalServerError = "internal_server_error"
   """Internal server error occurred"""
+  RecoveryError = "recovery_error"
+  """Recovery error occurred"""
   NotFound = "not_found"
   """Requested resource not found"""
 
@@ -715,6 +915,10 @@ class GripperKindEnum(Enum):
   """An OnRobot 3FG15 Gripper is connected"""
   DhAg = "dh_ag"
   """A DH AG Gripper is connected"""
+  DhPgc = "dh_pgc"
+  """A DH PGC Gripper is connected"""
+  DhCgi = "dh_cgi"
+  """A DH CGI Gripper is connected"""
   NoneConnected = "none_connected"
   """No gripper is connected"""
 
@@ -724,6 +928,66 @@ 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,
+  )
+
+def serialize_io_state_response(data: IOStateResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_str(data.state),
+  }
+
+@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:
+  return {
+    "state": None if data.state is None else serialize_str(data.state),
+  }
+
 JointRotations = Tuple[float,float,float,float,float,float,]
 
 def parse_joint_rotations(data: object) -> JointRotations:
@@ -990,6 +1254,18 @@ def parse_robot_control_mode_enum(data: object) -> RobotControlModeEnum:
 def serialize_robot_control_mode_enum(data: Union[RobotControlModeEnum, str]) -> object:
   return RobotControlModeEnum(data).value
 
+class ROSControlStateEnum(Enum):
+  Enabled = "enabled"
+  """ROS control is enabled."""
+  Disabled = "disabled"
+  """ROS control is disabled."""
+
+def parse_ros_control_state_enum(data: object) -> ROSControlStateEnum:
+  return ROSControlStateEnum(data)
+
+def serialize_ros_control_state_enum(data: Union[ROSControlStateEnum, str]) -> object:
+  return ROSControlStateEnum(data).value
+
 RoutineVariablesStateMap = Dict[str, str]
 
 def parse_routine_variables_state_map(data: object) -> RoutineVariablesStateMap:
@@ -1338,6 +1614,81 @@ def serialize_camera_frame_request(data: CameraFrameRequest) -> object:
     "camera_settings": None if data.camera_settings is None else serialize_camera_settings(data.camera_settings),
   }
 
+@dataclass
+class JointState:
+  """State of a joint"""
+  braked: Union[bool, None] = None
+  connectionStatus: Union[ConnectionStatus, None] = None
+  inCollision: Union[bool, None] = None
+  disturbance: Union[float, None] = None
+
+  def validate_braked(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "braked must be of type bool for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_connectionStatus(self, value: ConnectionStatus) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and ConnectionStatus in ['connected', 'disconnected', 'ready']) or isinstance(value, ConnectionStatus)):
+      return [False, "connectionStatus must be of type ConnectionStatus for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_inCollision(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "inCollision must be of type bool for JointState, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_disturbance(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "disturbance must be of type float for JointState, 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_braked(self.braked)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_connectionStatus(self.connectionStatus)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_inCollision(self.inCollision)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_disturbance(self.disturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_joint_state(data: object):
+  return JointState(
+    braked=parse_bool(data["braked"]) if "braked" in data else None,
+    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data else None,
+    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data else None,
+    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data else None,
+  )
+
+def serialize_joint_state(data: JointState) -> object:
+  return {
+    "braked": None if data.braked is None else serialize_bool(data.braked),
+    "connectionStatus": None if data.connectionStatus is None else serialize_connection_status(data.connectionStatus),
+    "inCollision": None if data.inCollision is None else serialize_bool(data.inCollision),
+    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
+  }
+
 EnvironmentVariablesList = List[EnvironmentVariable]
 
 def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
@@ -1356,7 +1707,7 @@ class ErrorResponse:
     if value is None:
       return [False, "error is required for ErrorResponse"]
 
-    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'not_found']) or isinstance(value, ErrorEnum)):
+    if not ((isinstance(value, str) and ErrorEnum in ['authorization_required', 'routine_must_be_running', 'api_control_required', 'robot_brakes_disengage_failed', 'robot_brakes_engage_failed', 'request_failed_validation', 'robot_not_idle', 'brakes_must_be_engaged', 'brakes_must_be_disengaged', 'equipment_no_matching', 'service_initializing', 'camera_disconnected', 'settings_validation_error', 'settings_timeout', 'internal_server_error', 'recovery_error', 'not_found']) or isinstance(value, ErrorEnum)):
       return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
@@ -1442,12 +1793,14 @@ class GripperConfiguration:
   """Configuration of gripper, also known as End Effector"""
   kind: Union[GripperKindEnum, None] = None
   dh_ag: Union[DHAGGripperConfiguration, None] = None
+  dh_pgc: Union[DHPGCGripperConfiguration, None] = None
+  dh_cgi: Union[DHCGIGripperConfiguration, None] = None
 
   def validate_kind(self, value: GripperKindEnum) -> Tuple[bool, str]:
     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', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
@@ -1461,6 +1814,24 @@ class GripperConfiguration:
 
     return [True, ""]
 
+  def validate_dh_pgc(self, value: DHPGCGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHPGCGripperConfiguration):
+      return [False, "dh_pgc must be of type DHPGCGripperConfiguration for GripperConfiguration, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_dh_cgi(self, value: DHCGIGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHCGIGripperConfiguration):
+      return [False, "dh_cgi must be of type DHCGIGripperConfiguration for GripperConfiguration, 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)
@@ -1469,17 +1840,27 @@ class GripperConfiguration:
     is_valid, error_str = self.validate_dh_ag(self.dh_ag)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_pgc(self.dh_pgc)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_gripper_configuration(data: object):
   return GripperConfiguration(
     kind=parse_gripper_kind_enum(data["kind"]) if "kind" in data else None,
     dh_ag=parse_dhag_gripper_configuration(data["dh_ag"]) if "dh_ag" in data else None,
+    dh_pgc=parse_dhpgc_gripper_configuration(data["dh_pgc"]) if "dh_pgc" in data else None,
+    dh_cgi=parse_dhcgi_gripper_configuration(data["dh_cgi"]) if "dh_cgi" in data else None,
   )
 
 def serialize_gripper_configuration(data: GripperConfiguration) -> object:
   return {
     "kind": serialize_gripper_kind_enum(data.kind),
     "dh_ag": None if data.dh_ag is None else serialize_dhag_gripper_configuration(data.dh_ag),
+    "dh_pgc": None if data.dh_pgc is None else serialize_dhpgc_gripper_configuration(data.dh_pgc),
+    "dh_cgi": None if data.dh_cgi is None else serialize_dhcgi_gripper_configuration(data.dh_cgi),
   }
 
 @dataclass
@@ -1716,6 +2097,66 @@ def serialize_robot_control_mode(data: RobotControlMode) -> object:
     "kind": None if data.kind is None else serialize_robot_control_mode_enum(data.kind),
   }
 
+@dataclass
+class ROSControlStateResponse:
+  """Response to a query for the current state of ROS control."""
+  state: Union[ROSControlStateEnum, None] = None
+
+  def validate_state(self, value: ROSControlStateEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and ROSControlStateEnum in ['enabled', 'disabled']) or isinstance(value, ROSControlStateEnum)):
+      return [False, "state must be of type ROSControlStateEnum for ROSControlStateResponse, 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_ros_control_state_response(data: object):
+  return ROSControlStateResponse(
+    state=parse_ros_control_state_enum(data["state"]) if "state" in data else None,
+  )
+
+def serialize_ros_control_state_response(data: ROSControlStateResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_ros_control_state_enum(data.state),
+  }
+
+@dataclass
+class ROSControlUpdateRequest:
+  """Request to update the state of direct ROS control."""
+  action: Union[ROSControlStateEnum, None] = None
+
+  def validate_action(self, value: ROSControlStateEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and ROSControlStateEnum in ['enabled', 'disabled']) or isinstance(value, ROSControlStateEnum)):
+      return [False, "action must be of type ROSControlStateEnum for ROSControlUpdateRequest, 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)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_ros_control_update_request(data: object):
+  return ROSControlUpdateRequest(
+    action=parse_ros_control_state_enum(data["action"]) if "action" in data else None,
+  )
+
+def serialize_ros_control_update_request(data: ROSControlUpdateRequest) -> object:
+  return {
+    "action": None if data.action is None else serialize_ros_control_state_enum(data.action),
+  }
+
 @dataclass
 class PlayRoutineRequest:
   """Request to play a routine"""
@@ -1897,6 +2338,111 @@ def serialize_arm_position_update_request_response_event_stream_details(data: Ar
     "subscriptions": serialize_arm_position_update_request_response_event_stream_subscriptions_list(data.subscriptions),
   }
 
+@dataclass
+class JointsStateResponse:
+  """Response to a query for the current state of the joints"""
+  J0: Union[JointState, None] = None
+  J1: Union[JointState, None] = None
+  J2: Union[JointState, None] = None
+  J3: Union[JointState, None] = None
+  J4: Union[JointState, None] = None
+  J5: Union[JointState, None] = None
+
+  def validate_J0(self, value: JointState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointState):
+      return [False, "J0 must be of type JointState for JointsStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_J1(self, value: JointState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointState):
+      return [False, "J1 must be of type JointState for JointsStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_J2(self, value: JointState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointState):
+      return [False, "J2 must be of type JointState for JointsStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_J3(self, value: JointState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointState):
+      return [False, "J3 must be of type JointState for JointsStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_J4(self, value: JointState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointState):
+      return [False, "J4 must be of type JointState for JointsStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_J5(self, value: JointState) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointState):
+      return [False, "J5 must be of type JointState for JointsStateResponse, 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_J0(self.J0)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_J1(self.J1)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_J2(self.J2)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_J3(self.J3)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_J4(self.J4)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_J5(self.J5)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_joints_state_response(data: object):
+  return JointsStateResponse(
+    J0=parse_joint_state(data["J0"]) if "J0" in data else None,
+    J1=parse_joint_state(data["J1"]) if "J1" in data else None,
+    J2=parse_joint_state(data["J2"]) if "J2" in data else None,
+    J3=parse_joint_state(data["J3"]) if "J3" in data else None,
+    J4=parse_joint_state(data["J4"]) if "J4" in data else None,
+    J5=parse_joint_state(data["J5"]) if "J5" in data else None,
+  )
+
+def serialize_joints_state_response(data: JointsStateResponse) -> object:
+  return {
+    "J0": None if data.J0 is None else serialize_joint_state(data.J0),
+    "J1": None if data.J1 is None else serialize_joint_state(data.J1),
+    "J2": None if data.J2 is None else serialize_joint_state(data.J2),
+    "J3": None if data.J3 is None else serialize_joint_state(data.J3),
+    "J4": None if data.J4 is None else serialize_joint_state(data.J4),
+    "J5": None if data.J5 is None else serialize_joint_state(data.J5),
+  }
+
 @dataclass
 class Routine:
   """Robot Routine containing steps to automate robot movement and operations"""
@@ -2299,12 +2845,14 @@ class GripperCommandRequest:
   onrobot_2fg7: Union[OnRobot2FG7GripperCommandRequest, 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
 
   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', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_3fg15', 'dh_ag', 'dh_pgc', 'dh_cgi', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -2336,6 +2884,24 @@ class GripperCommandRequest:
 
     return [True, ""]
 
+  def validate_dh_pgc(self, value: DHPGCGripperCommandRequest) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHPGCGripperCommandRequest):
+      return [False, "dh_pgc must be of type DHPGCGripperCommandRequest for GripperCommandRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_dh_cgi(self, value: DHCGIGripperCommandRequest) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHCGIGripperCommandRequest):
+      return [False, "dh_cgi must be of type DHCGIGripperCommandRequest 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)
@@ -2350,6 +2916,12 @@ class GripperCommandRequest:
     is_valid, error_str = self.validate_dh_ag(self.dh_ag)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_pgc(self.dh_pgc)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_cgi(self.dh_cgi)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_gripper_command_request(data: object):
   return GripperCommandRequest(
@@ -2357,6 +2929,8 @@ def parse_gripper_command_request(data: object):
     onrobot_2fg7=parse_on_robot_2_fg_7_gripper_command_request(data["onrobot_2fg7"]) if "onrobot_2fg7" 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,
   )
 
 def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
@@ -2365,6 +2939,8 @@ def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
     "onrobot_2fg7": None if data.onrobot_2fg7 is None else serialize_on_robot_2_fg_7_gripper_command_request(data.onrobot_2fg7),
     "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),
   }
 
 @dataclass

{standardbots-2.20240401.11 → standardbots-2.20240614.1}/standardbots.egg-info/PKG-INFO

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