standardbots 2.0.0.dev1736521463__py3-none-any.whl → 2.0.0.dev1736549071__py3-none-any.whl

standardbots/auto_generated/apis.py

@@ -188,7 +188,7 @@ class Default:
             return self.control_gripper(
                 body=models.GripperCommandRequest(
                     kind=models.GripperKindEnum.DhCgi,
-                    dh_pgc=models.DHCGIGripperCommandRequest(
+                    dh_cgi=models.DHCGIGripperCommandRequest(
                         target_diameter, target_force, target_speed
                     ),
                 ),
@@ -713,7 +713,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera.
+            Retrieve the latest RGB frame from the camera. In JPEG format.
             """
             path = "/api/v1/camera/frame/rgb"
             try:

standardbots/auto_generated/models.py

@@ -1372,6 +1372,66 @@ def parse_joint_rotations(data: object) -> JointRotations:
 def serialize_joint_rotations(data: JointRotations) -> object:
   return [serialize_f_64(data[0]),serialize_f_64(data[1]),serialize_f_64(data[2]),serialize_f_64(data[3]),serialize_f_64(data[4]),serialize_f_64(data[5]),]
 
+@dataclass
+class JointStateDisturbance:
+  """Disturbance of a joint"""
+  disturbance: Union[float, None] = None
+  amperageDisturbance: Union[float, None] = None
+  windupDisturbance: Union[float, None] = None
+
+  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 JointStateDisturbance, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_amperageDisturbance(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "amperageDisturbance must be of type float for JointStateDisturbance, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_windupDisturbance(self, value: float) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, float):
+      return [False, "windupDisturbance must be of type float for JointStateDisturbance, 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_disturbance(self.disturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_amperageDisturbance(self.amperageDisturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_windupDisturbance(self.windupDisturbance)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_joint_state_disturbance(data: object):
+  return JointStateDisturbance(
+    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None else None,
+    amperageDisturbance=parse_f_64(data["amperageDisturbance"]) if "amperageDisturbance" in data and data.get("amperageDisturbance") is not None else None,
+    windupDisturbance=parse_f_64(data["windupDisturbance"]) if "windupDisturbance" in data and data.get("windupDisturbance") is not None else None,
+  )
+
+def serialize_joint_state_disturbance(data: JointStateDisturbance) -> object:
+  return {
+    "disturbance": None if data.disturbance is None else serialize_f_64(data.disturbance),
+    "amperageDisturbance": None if data.amperageDisturbance is None else serialize_f_64(data.amperageDisturbance),
+    "windupDisturbance": None if data.windupDisturbance is None else serialize_f_64(data.windupDisturbance),
+  }
+
 class LinearGripDirectionEnum(Enum):
   Inward = "inward"
   """Move gripper inward to grip. Measure grip position based on interior of gripper fingers and exterior of object"""
@@ -2655,7 +2715,7 @@ def serialize_camera_intrinsics_response(data: CameraIntrinsicsResponse) -> obje
 
 @dataclass
 class CameraFrameRequest:
-  """Request for a single camera frame."""
+  """Request for a single camera frame. In JPEG format."""
   camera_settings: Union[CameraSettings, None] = None
 
   def validate_camera_settings(self, value: CameraSettings) -> Tuple[bool, str]:
@@ -2959,81 +3019,6 @@ def serialize_tooltip_position_response(data: TooltipPositionResponse) -> object
     "pose": None if data.pose is None else serialize_cartesian_pose(data.pose),
   }
 
-@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 and data.get("braked") is not None else None,
-    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data and data.get("connectionStatus") is not None else None,
-    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data and data.get("inCollision") is not None else None,
-    disturbance=parse_f_64(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None 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:
@@ -3345,6 +3330,81 @@ def serialize_arm_joint_rotations(data: ArmJointRotations) -> object:
     "joints": serialize_joint_rotations(data.joints),
   }
 
+@dataclass
+class JointState:
+  """State of a joint"""
+  braked: Union[bool, None] = None
+  connectionStatus: Union[ConnectionStatus, None] = None
+  inCollision: Union[bool, None] = None
+  disturbance: Union[JointStateDisturbance, 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: JointStateDisturbance) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, JointStateDisturbance):
+      return [False, "disturbance must be of type JointStateDisturbance 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 and data.get("braked") is not None else None,
+    connectionStatus=parse_connection_status(data["connectionStatus"]) if "connectionStatus" in data and data.get("connectionStatus") is not None else None,
+    inCollision=parse_bool(data["inCollision"]) if "inCollision" in data and data.get("inCollision") is not None else None,
+    disturbance=parse_joint_state_disturbance(data["disturbance"]) if "disturbance" in data and data.get("disturbance") is not None 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_joint_state_disturbance(data.disturbance),
+  }
+
 @dataclass
 class LinearUnit:
   """Reusable Abstraction for linear units (eg distance, position, offset)
@@ -4863,6 +4923,74 @@ 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 Routine:
+  """Robot Routine containing steps to automate robot movement and operations"""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
+  environment_variables: Union[EnvironmentVariablesList, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for Routine, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "name must be of type str for Routine, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_environment_variables(self, value: EnvironmentVariablesList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, EnvironmentVariable) for x in value)):
+      return [False, "environment_variables must be of type EnvironmentVariablesList for Routine, 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_id(self.id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_name(self.name)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_environment_variables(self.environment_variables)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_routine(data: object):
+  return Routine(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
+    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data and data.get("environment_variables") is not None else None,
+  )
+
+def serialize_routine(data: Routine) -> object:
+  return {
+    "id": None if data.id is None else serialize_str(data.id),
+    "name": None if data.name is None else serialize_str(data.name),
+    "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
+  }
+
+ArmJointRotationsList = List[ArmJointRotations]
+
+def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
+  return [parse_arm_joint_rotations(item) for item in data]
+
+def serialize_arm_joint_rotations_list(data: ArmJointRotationsList) -> List[object]:
+  return [serialize_arm_joint_rotations(item) for item in data]
+
 @dataclass
 class JointsStateResponse:
   """Response to a query for the current state of the joints"""
@@ -4968,74 +5096,6 @@ def serialize_joints_state_response(data: JointsStateResponse) -> object:
     "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"""
-  id: Union[str, None] = None
-  name: Union[str, None] = None
-  environment_variables: Union[EnvironmentVariablesList, None] = None
-
-  def validate_id(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "id must be of type str for Routine, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_name(self, value: str) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not isinstance(value, str):
-      return [False, "name must be of type str for Routine, got " + type(value).__name__]
-
-    return [True, ""]
-
-  def validate_environment_variables(self, value: EnvironmentVariablesList) -> Tuple[bool, str]:
-    if value is None:
-      return [True, ""]
-
-    if not (isinstance(value, list) and all(isinstance(x, EnvironmentVariable) for x in value)):
-      return [False, "environment_variables must be of type EnvironmentVariablesList for Routine, 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_id(self.id)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_name(self.name)
-    if not is_valid:
-      raise TypeError(error_str)
-    is_valid, error_str = self.validate_environment_variables(self.environment_variables)
-    if not is_valid:
-      raise TypeError(error_str)
-
-def parse_routine(data: object):
-  return Routine(
-    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
-    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
-    environment_variables=parse_environment_variables_list(data["environment_variables"]) if "environment_variables" in data and data.get("environment_variables") is not None else None,
-  )
-
-def serialize_routine(data: Routine) -> object:
-  return {
-    "id": None if data.id is None else serialize_str(data.id),
-    "name": None if data.name is None else serialize_str(data.name),
-    "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
-  }
-
-ArmJointRotationsList = List[ArmJointRotations]
-
-def parse_arm_joint_rotations_list(data: object) -> ArmJointRotationsList:
-  return [parse_arm_joint_rotations(item) for item in data]
-
-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

{standardbots-2.0.0.dev1736521463.dist-info → standardbots-2.0.0.dev1736549071.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: standardbots
-Version: 2.0.0.dev1736521463
+Version: 2.0.0.dev1736549071
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

standardbots-2.0.0.dev1736549071.dist-info/RECORD

@@ -0,0 +1,8 @@
+standardbots/__init__.py,sha256=PT6Z2HPama2fb6SaNhF3J1skpYABQWGgDzKEtQY6BDM,29
+standardbots/auto_generated/__init__.py,sha256=PZtDUzYcjIO6R-gE-0NzY0vFXk1Je1tJ3je0ivV5o-k,98
+standardbots/auto_generated/apis.py,sha256=G3sh8CbbfjxoFTmzc8xI4swajPxD5xOWTaKg6hjY5kg,91393
+standardbots/auto_generated/models.py,sha256=AECDa7g9WYqC8QOuxFnc36wBhXmS1J0t7saaysLfOTc,261743
+standardbots-2.0.0.dev1736549071.dist-info/METADATA,sha256=S7nE6v6v-4fadRG1c_DkDPruhvBcU8GMZH_uYtNOjp0,558
+standardbots-2.0.0.dev1736549071.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+standardbots-2.0.0.dev1736549071.dist-info/top_level.txt,sha256=8Cb2uu5PLn7ayueFHSdWnFlKJzvSezDEKTHiup_bxH0,13
+standardbots-2.0.0.dev1736549071.dist-info/RECORD,,

standardbots-2.0.0.dev1736521463.dist-info/RECORD

@@ -1,8 +0,0 @@
-standardbots/__init__.py,sha256=PT6Z2HPama2fb6SaNhF3J1skpYABQWGgDzKEtQY6BDM,29
-standardbots/auto_generated/__init__.py,sha256=PZtDUzYcjIO6R-gE-0NzY0vFXk1Je1tJ3je0ivV5o-k,98
-standardbots/auto_generated/apis.py,sha256=60i0Alae1dIC3BFK_s0YZRMvVcC3VmxKVsuhSJGDzHc,91377
-standardbots/auto_generated/models.py,sha256=KOKTkI8z_Z6QAe5_QezTgrq6_6QX7pJmFIAPS96N_2c,259088
-standardbots-2.0.0.dev1736521463.dist-info/METADATA,sha256=51MdaSe6rz_adY4L_DeaUJP8ohVgSvPDVBarmm_QXK0,558
-standardbots-2.0.0.dev1736521463.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-standardbots-2.0.0.dev1736521463.dist-info/top_level.txt,sha256=8Cb2uu5PLn7ayueFHSdWnFlKJzvSezDEKTHiup_bxH0,13
-standardbots-2.0.0.dev1736521463.dist-info/RECORD,,