standardbots 2.20240212.10__py3-none-any.whl → 2.20241003.41__py3-none-any.whl

standardbots/auto_generated/apis.py

@@ -53,9 +53,11 @@ class RequestManager:
 
   def json_headers(self) -> Dict[str, str]:
     return {
-      "Content-Type": "application/json",
-      "Authorization": "Bearer " + self.token,
-      "robot_kind": self.robot_kind.value,
+        "Content-Type": "application/json",
+        "Authorization": "Bearer " + self.token,
+        # Include both for backwards-compatibility purposes.
+        "robot_kind": self.robot_kind.value,
+        "robot-kind": self.robot_kind.value,
     }
 
   def close(self):
@@ -117,6 +119,70 @@ 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 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(
       self,
@@ -416,13 +482,17 @@ class Movement:
       position: models.Position,
       orientation: models.Orientation,
       reference_frame: str = 'base',
-      axis_alignment: str = 'base'
+      axis_alignment: str = 'base',
+      local_accuracy_calibration: str | None = None,
+      movement_kind: models.MovementKindEnum | None = models.MovementKindEnum.Joint,
     ):
       return self.move_tooltip(
         position=position,
         orientation=orientation,
         reference_frame=reference_frame,
-        axis_alignment=axis_alignment
+        axis_alignment=axis_alignment,
+        local_accuracy_calibration=local_accuracy_calibration,
+        movement_kind=movement_kind
       )
     
     def move_tooltip(
@@ -430,7 +500,9 @@ class Movement:
       position: models.Position,
       orientation: models.Orientation,
       reference_frame: str = 'base',
-      axis_alignment: str = 'base'
+      axis_alignment: str = 'base',
+      local_accuracy_calibration: str | None = None,
+      movement_kind: models.MovementKindEnum | None = models.MovementKindEnum.Joint
     ):
       """Move tooltip of robot to specified position
       """
@@ -440,6 +512,7 @@ class Movement:
           position=position,
           orientation=orientation,
           reference_frame=reference_frame,
+          local_accuracy_calibration=local_accuracy_calibration,
           axis_alignment=axis_alignment,
         ),
       )
@@ -525,6 +598,582 @@ 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/rgb"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+        preload_content=False,
+      )
+      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 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:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def speech_to_text(
+      self,
+      body: models.SpeechToTextRequest,
+    ) -> Response[
+      None,
+      None
+    ]:
+      """
+      Convert speech to text.
+      """
+      path = "/api/v1/internal-only/speech-to-text"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_speech_to_text_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 text_to_skill(
+      self,
+      body: models.TextToSkillRequest,
+    ) -> Response[
+      None,
+      None
+    ]:
+      """
+      Convert text to a skill.
+      """
+      path = "/api/v1/internal-only/text-to-skill"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_text_to_skill_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
+      )
+
+  data: Data
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = 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 (&#x27;high&#x27; or &#x27;low&#x27;).
+      """
+      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.FailureStateResponse,
+        models.ErrorResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.FailureStateResponse
+    ]:
+      """
+      Attempts to recover the robot from a fault state. Inspect the response to determine if additional recovery actions are required.
+
+      """
+      path = "/api/v1/recovery/recover"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_failure_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
+      )
+
+    def get_status(
+      self,
+    ) -> Response[
+      Union[
+        models.FailureStateResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.FailureStateResponse
+    ]:
+      """
+      Get the robot&#x27;s recovery status.
+
+      """
+      path = "/api/v1/recovery/status"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_failure_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
+      )
+
+  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
   class Routines:
@@ -705,7 +1354,7 @@ class RoutineEditor:
 
     def load(
       self,
-      variable_id: str,
+      variable_name: str,
     ) -> Response[
       Union[
         models.RuntimeVariable,
@@ -717,8 +1366,8 @@ class RoutineEditor:
       """
       Returns current state of a variable
       """
-      path = "/api/v1/routine-editor/variables/{variable_id}"
-      path = path.replace("{variable_id}", str(variable_id))
+      path = "/api/v1/routine-editor/variables/{variable_name}"
+      path = path.replace("{variable_name}", str(variable_name))
       response = self._request_manager.request(
         "GET",
         path,
@@ -742,7 +1391,7 @@ class RoutineEditor:
     def update(
       self,
       body: models.RuntimeVariable,
-      variable_id: str,
+      variable_name: str,
     ) -> Response[
       Union[
         models.RuntimeVariable,
@@ -754,8 +1403,8 @@ class RoutineEditor:
       """
       Update the value of a variable
       """
-      path = "/api/v1/routine-editor/variables/{variable_id}"
-      path = path.replace("{variable_id}", str(variable_id))
+      path = "/api/v1/routine-editor/variables/{variable_name}"
+      path = path.replace("{variable_name}", str(variable_name))
       response = self._request_manager.request(
         "POST",
         path,
@@ -916,6 +1565,13 @@ class StandardBotsRobot(Default):
   RobotKind = RobotKind
 
   movement: Movement
+  camera: Camera
+  faults: Faults
+  chat_gpt: ChatGPT
+  io: IO
+  general: General
+  recovery: Recovery
+  ros: ROS
   routine_editor: RoutineEditor
   status: Status
   def __init__(
@@ -932,6 +1588,13 @@ class StandardBotsRobot(Default):
       robot_kind=RobotKind(robot_kind),
     ))
     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)
+    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)