standardbots 2.20240212.14__tar.gz → 2.20240212.16__tar.gz

{standardbots-2.20240212.14 → standardbots-2.20240212.16}/PKG-INFO

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

{standardbots-2.20240212.14 → standardbots-2.20240212.16}/setup.py

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

{standardbots-2.20240212.14 → standardbots-2.20240212.16}/standardbots/auto_generated/apis.py

@@ -117,6 +117,28 @@ class Default:
         )
       )
     
+    def dh_ag_grip(
+        self,
+        target_diameter: float,
+        target_force: float | None,
+        target_speed: float | None,
+    ):
+        """
+        Control the DH AG 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.DhAg,
+                dh_ag=models.DHAGGripperCommandRequest(
+                    target_diameter, target_force, target_speed
+                ),
+            ),
+        )
+    
 
     def control_gripper(
       self,
@@ -525,6 +547,142 @@ class Movement:
     self.brakes = Movement.Brakes(request_manager)
     self.position = Movement.Position(request_manager)
 
+class Camera:
+  _request_manager: RequestManager
+  class Data:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def get_color_frame(
+      self,
+      body: models.CameraFrameRequest,
+    ) -> Response[
+      None,
+      None
+    ]:
+      """
+      Retrieve the latest RGB frame from the camera.
+      """
+      path = "/api/v1/camera/frame/rgb"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_camera_frame_request(body)),
+      )
+      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
+      )
+
+    def get_camera_intrinsics_color(
+      self,
+    ) -> Response[
+      None,
+      None
+    ]:
+      """
+      Retrieve the intrinsic parameters for the color camera.
+      """
+      path = "/api/v1/camera/intrinsics/rgb"
+      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
+      )
+
+    def get_camera_stream(
+      self,
+    ) -> Response[
+      None,
+      None
+    ]:
+      """
+      Retrieve the latest RGB frame from the camera.
+      """
+      path = "/api/v1/camera/stream"
+      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
+      )
+
+  class Settings:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def set_camera_settings(
+      self,
+      body: models.CameraSettings,
+    ) -> Response[
+      None,
+      None
+    ]:
+      """
+      Set the camera settings.
+      """
+      path = "/api/v1/camera/settings"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_camera_settings(body)),
+      )
+      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
+      )
+
+  data: Data
+  settings: Settings
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = request_manager
+    self.data = Camera.Data(request_manager)
+    self.settings = Camera.Settings(request_manager)
+
 class RoutineEditor:
   _request_manager: RequestManager
   class Routines:
@@ -916,6 +1074,7 @@ class StandardBotsRobot(Default):
   RobotKind = RobotKind
 
   movement: Movement
+  camera: Camera
   routine_editor: RoutineEditor
   status: Status
   def __init__(
@@ -932,6 +1091,7 @@ class StandardBotsRobot(Default):
       robot_kind=RobotKind(robot_kind),
     ))
     self.movement = Movement(self._request_manager)
+    self.camera = Camera(self._request_manager)
     self.routine_editor = RoutineEditor(self._request_manager)
     self.status = Status(self._request_manager)
 

{standardbots-2.20240212.14 → standardbots-2.20240212.16}/standardbots/auto_generated/models.py

@@ -236,6 +236,337 @@ def parse_brakes_state_enum(data: object) -> BrakesStateEnum:
 def serialize_brakes_state_enum(data: Union[BrakesStateEnum, str]) -> object:
   return BrakesStateEnum(data).value
 
+@dataclass
+class CameraIntrinsics:
+  """Intrinsic parameters of the camera."""
+  width: Union[float, None] = None
+  height: Union[float, None] = None
+  fx: Union[float, None] = None
+  fy: Union[float, None] = None
+  ppx: Union[float, None] = None
+  ppy: Union[float, None] = None
+  error: Union[int, None] = None
+
+  def validate_width(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "width must be of type float for CameraIntrinsics, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_height(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "height must be of type float for CameraIntrinsics, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_fx(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "fx must be of type float for CameraIntrinsics, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_fy(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "fy must be of type float for CameraIntrinsics, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_ppx(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "ppx must be of type float for CameraIntrinsics, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_ppy(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "ppy must be of type float for CameraIntrinsics, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_error(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "error must be of type int for CameraIntrinsics, 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_width(self.width)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_height(self.height)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_fx(self.fx)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_fy(self.fy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_ppx(self.ppx)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_ppy(self.ppy)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_error(self.error)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_intrinsics(data: object):
+  return CameraIntrinsics(
+    width=parse_f_64(data["width"]) if "width" in data else None,
+    height=parse_f_64(data["height"]) if "height" in data else None,
+    fx=parse_f_64(data["fx"]) if "fx" in data else None,
+    fy=parse_f_64(data["fy"]) if "fy" in data else None,
+    ppx=parse_f_64(data["ppx"]) if "ppx" in data else None,
+    ppy=parse_f_64(data["ppy"]) if "ppy" in data else None,
+    error=parse_i_8(data["error"]) if "error" in data else None,
+  )
+
+def serialize_camera_intrinsics(data: CameraIntrinsics) -> object:
+  return {
+    "width": None if data.width is None else serialize_f_64(data.width),
+    "height": None if data.height is None else serialize_f_64(data.height),
+    "fx": None if data.fx is None else serialize_f_64(data.fx),
+    "fy": None if data.fy is None else serialize_f_64(data.fy),
+    "ppx": None if data.ppx is None else serialize_f_64(data.ppx),
+    "ppy": None if data.ppy is None else serialize_f_64(data.ppy),
+    "error": None if data.error is None else serialize_i_8(data.error),
+  }
+
+@dataclass
+class CameraSettings:
+  """Settings for the camera."""
+  brightness: Union[int, None] = None
+  contrast: Union[int, None] = None
+  exposure: Union[int, None] = None
+  sharpness: Union[int, None] = None
+  hue: Union[int, None] = None
+  whiteBalance: Union[int, None] = None
+  autoWhiteBalance: Union[bool, None] = None
+
+  def validate_brightness(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "brightness must be of type int for CameraSettings, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_contrast(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "contrast must be of type int for CameraSettings, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_exposure(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "exposure must be of type int for CameraSettings, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_sharpness(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "sharpness must be of type int for CameraSettings, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_hue(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "hue must be of type int for CameraSettings, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_whiteBalance(self, value: int) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, int):
+      return [False, "whiteBalance must be of type int for CameraSettings, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_autoWhiteBalance(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, bool):
+      return [False, "autoWhiteBalance must be of type bool for CameraSettings, 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_brightness(self.brightness)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_contrast(self.contrast)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_exposure(self.exposure)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_sharpness(self.sharpness)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_hue(self.hue)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_whiteBalance(self.whiteBalance)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_autoWhiteBalance(self.autoWhiteBalance)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_settings(data: object):
+  return CameraSettings(
+    brightness=parse_i_16(data["brightness"]) if "brightness" in data else None,
+    contrast=parse_i_16(data["contrast"]) if "contrast" in data else None,
+    exposure=parse_i_16(data["exposure"]) if "exposure" in data else None,
+    sharpness=parse_i_16(data["sharpness"]) if "sharpness" in data else None,
+    hue=parse_i_16(data["hue"]) if "hue" in data else None,
+    whiteBalance=parse_i_16(data["whiteBalance"]) if "whiteBalance" in data else None,
+    autoWhiteBalance=parse_bool(data["autoWhiteBalance"]) if "autoWhiteBalance" in data else None,
+  )
+
+def serialize_camera_settings(data: CameraSettings) -> object:
+  return {
+    "brightness": None if data.brightness is None else serialize_i_16(data.brightness),
+    "contrast": None if data.contrast is None else serialize_i_16(data.contrast),
+    "exposure": None if data.exposure is None else serialize_i_16(data.exposure),
+    "sharpness": None if data.sharpness is None else serialize_i_16(data.sharpness),
+    "hue": None if data.hue is None else serialize_i_16(data.hue),
+    "whiteBalance": None if data.whiteBalance is None else serialize_i_16(data.whiteBalance),
+    "autoWhiteBalance": None if data.autoWhiteBalance is None else serialize_bool(data.autoWhiteBalance),
+  }
+
+@dataclass
+class DHAGGripperCommandRequest:
+  """Control the DH AG 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 DHAGGripperCommandRequest"]
+
+    if not isinstance(value, float):
+      return [False, "target_diameter must be of type float for DHAGGripperCommandRequest, 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 DHAGGripperCommandRequest, 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 DHAGGripperCommandRequest, 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_dhag_gripper_command_request(data: object):
+  return DHAGGripperCommandRequest(
+    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_dhag_gripper_command_request(data: DHAGGripperCommandRequest) -> 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 DHAGGripperConfiguration:
+  """Configuration for DH AG 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 DHAGGripperConfiguration"]
+
+    if not isinstance(value, float):
+      return [False, "diameter must be of type float for DHAGGripperConfiguration, 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_dhag_gripper_configuration(data: object):
+  return DHAGGripperConfiguration(
+    diameter=parse_f_64(data["diameter"]) if "diameter" in data else None,
+  )
+
+def serialize_dhag_gripper_configuration(data: DHAGGripperConfiguration) -> 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.
@@ -348,6 +679,16 @@ class ErrorEnum(Enum):
   """No matching equipment found"""
   ServiceInitializing = "service_initializing"
   """The service is unavailable while initializing"""
+  CameraDisconnected = "camera_disconnected"
+  """Camera service running, but no camera is connected"""
+  SettingsValidationError = "settings_validation_error"
+  """Camera settings validation failed"""
+  SettingsTimeout = "settings_timeout"
+  """Camera settings timed out"""
+  InternalServerError = "internal_server_error"
+  """Internal server error occurred"""
+  NotFound = "not_found"
+  """Requested resource not found"""
 
 def parse_error_enum(data: object) -> ErrorEnum:
   return ErrorEnum(data)
@@ -372,6 +713,8 @@ class GripperKindEnum(Enum):
   """An OnRobot 2FG7 Gripper is connected"""
   Onrobot3Fg15 = "onrobot_3fg15"
   """An OnRobot 3FG15 Gripper is connected"""
+  DhAg = "dh_ag"
+  """A DH AG Gripper is connected"""
   NoneConnected = "none_connected"
   """No gripper is connected"""
 
@@ -847,6 +1190,66 @@ def serialize_brakes_state(data: BrakesState) -> object:
     "state": serialize_brakes_state_enum(data.state),
   }
 
+@dataclass
+class CameraIntrinsicsResponse:
+  """Response with intrinsic parameters of the camera."""
+  intrinsics: Union[CameraIntrinsics, None] = None
+
+  def validate_intrinsics(self, value: CameraIntrinsics) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, CameraIntrinsics):
+      return [False, "intrinsics must be of type CameraIntrinsics for CameraIntrinsicsResponse, 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_intrinsics(self.intrinsics)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_intrinsics_response(data: object):
+  return CameraIntrinsicsResponse(
+    intrinsics=parse_camera_intrinsics(data["intrinsics"]) if "intrinsics" in data else None,
+  )
+
+def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> object:
+  return {
+    "intrinsics": None if data.intrinsics is None else serialize_camera_intrinsics(data.intrinsics),
+  }
+
+@dataclass
+class CameraFrameRequest:
+  """Request for a single camera frame."""
+  camera_settings: Union[CameraSettings, None] = None
+
+  def validate_camera_settings(self, value: CameraSettings) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, CameraSettings):
+      return [False, "camera_settings must be of type CameraSettings for CameraFrameRequest, 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_camera_settings(self.camera_settings)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_camera_frame_request(data: object):
+  return CameraFrameRequest(
+    camera_settings=parse_camera_settings(data["camera_settings"]) if "camera_settings" in data else None,
+  )
+
+def serialize_camera_frame_request(data: CameraFrameRequest) -> object:
+  return {
+    "camera_settings": None if data.camera_settings is None else serialize_camera_settings(data.camera_settings),
+  }
+
 EnvironmentVariablesList = List[EnvironmentVariable]
 
 def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
@@ -865,7 +1268,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']) 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', '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)):
       return [False, "error must be of type ErrorEnum for ErrorResponse, got " + type(value).__name__]
 
     return [True, ""]
@@ -950,30 +1353,45 @@ def serialize_force_unit(data: ForceUnit) -> object:
 class GripperConfiguration:
   """Configuration of gripper, also known as End Effector"""
   kind: Union[GripperKindEnum, None] = None
+  dh_ag: Union[DHAGGripperConfiguration, 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', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_3fg15', 'dh_ag', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperConfiguration, got " + type(value).__name__]
 
     return [True, ""]
 
+  def validate_dh_ag(self, value: DHAGGripperConfiguration) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHAGGripperConfiguration):
+      return [False, "dh_ag must be of type DHAGGripperConfiguration 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)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_ag(self.dh_ag)
+    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,
   )
 
 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),
   }
 
 @dataclass
@@ -1717,12 +2135,13 @@ class GripperCommandRequest:
   kind: Union[GripperKindEnum, None] = None
   onrobot_2fg7: Union[OnRobot2FG7GripperCommandRequest, None] = None
   onrobot_3fg15: Union[OnRobot3FG15GripperCommandRequest, None] = None
+  dh_ag: Union[DHAGGripperCommandRequest, 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', 'none_connected']) or isinstance(value, GripperKindEnum)):
+    if not ((isinstance(value, str) and GripperKindEnum in ['onrobot_2fg7', 'onrobot_3fg15', 'dh_ag', 'none_connected']) or isinstance(value, GripperKindEnum)):
       return [False, "kind must be of type GripperKindEnum for GripperCommandRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -1745,6 +2164,15 @@ class GripperCommandRequest:
 
     return [True, ""]
 
+  def validate_dh_ag(self, value: DHAGGripperCommandRequest) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, DHAGGripperCommandRequest):
+      return [False, "dh_ag must be of type DHAGGripperCommandRequest 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)
@@ -1756,12 +2184,16 @@ class GripperCommandRequest:
     is_valid, error_str = self.validate_onrobot_3fg15(self.onrobot_3fg15)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_dh_ag(self.dh_ag)
+    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_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,
   )
 
 def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
@@ -1769,6 +2201,7 @@ def serialize_gripper_command_request(data: GripperCommandRequest) -> object:
     "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_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),
   }
 
 @dataclass

{standardbots-2.20240212.14 → standardbots-2.20240212.16}/standardbots.egg-info/PKG-INFO

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