standardbots 2.20240212.19__tar.gz → 2.20240401.1__tar.gz

{standardbots-2.20240212.19 → standardbots-2.20240401.1}/PKG-INFO

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

{standardbots-2.20240212.19 → standardbots-2.20240401.1}/setup.py

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

{standardbots-2.20240212.19 → standardbots-2.20240401.1}/standardbots/auto_generated/apis.py

@@ -683,6 +683,79 @@ class Camera:
     self.data = Camera.Data(request_manager)
     self.settings = Camera.Settings(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 RoutineEditor:
   _request_manager: RequestManager
   class Routines:
@@ -1067,6 +1140,90 @@ class Status:
     self.control = Status.Control(request_manager)
     self.health = Status.Health(request_manager)
 
+class Teleoperation:
+  _request_manager: RequestManager
+  class Control:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def update_teleop_state(
+      self,
+      body: models.TeleopStateUpdateRequest,
+    ) -> Response[
+      Union[
+        models.TeleopStateResponse,
+        models.ErrorResponse,
+        None
+      ],
+      models.TeleopStateResponse
+    ]:
+      """
+      Updates the state of teleoperation based on the provided action (&#x27;start&#x27; or &#x27;stop&#x27;).
+      """
+      path = "/api/v1/movement/teleop/state"
+      response = self._request_manager.request(
+        "POST",
+        path,
+        headers=self._request_manager.json_headers(),
+        body=json.dumps(models.serialize_teleop_state_update_request(body)),
+      )
+      parsed = None
+      if response.status == 200:
+        parsed = models.parse_teleop_state_response(json.loads(response.data))
+
+      is_user_error = response.status >= 400 and response.status < 500
+      is_unavailable = response.status == 503
+      if parsed is None and (is_user_error or is_unavailable):
+        parsed = models.parse_error_response(json.loads(response.data))
+
+      return Response(
+        parsed,
+        response.status,
+        response
+      )
+
+  class Status:
+    def __init__(self, request_manager: RequestManager):
+      self._request_manager = request_manager
+
+
+    def get_teleop_state(
+      self,
+    ) -> Response[
+      None,
+      None
+    ]:
+      """
+      Retrieves the current state of teleoperation.
+      """
+      path = "/api/v1/movement/teleop/state"
+      response = self._request_manager.request(
+        "GET",
+        path,
+        headers=self._request_manager.json_headers(),
+      )
+      parsed = None
+
+      is_user_error = response.status >= 400 and response.status < 500
+      is_unavailable = response.status == 503
+      if parsed is None and (is_user_error or is_unavailable):
+        parsed = models.parse_error_response(json.loads(response.data))
+
+      return Response(
+        parsed,
+        response.status,
+        response
+      )
+
+  control: Control
+  status: Status
+
+  def __init__(self, request_manager: RequestManager):
+    self._request_manager = request_manager
+    self.control = Teleoperation.Control(request_manager)
+    self.status = Teleoperation.Status(request_manager)
+
 
 
 
@@ -1075,8 +1232,10 @@ class StandardBotsRobot(Default):
 
   movement: Movement
   camera: Camera
+  chat_gpt: ChatGpt
   routine_editor: RoutineEditor
   status: Status
+  teleoperation: Teleoperation
   def __init__(
     self,
     url: str,
@@ -1092,8 +1251,10 @@ class StandardBotsRobot(Default):
     ))
     self.movement = Movement(self._request_manager)
     self.camera = Camera(self._request_manager)
+    self.chat_gpt = ChatGpt(self._request_manager)
     self.routine_editor = RoutineEditor(self._request_manager)
     self.status = Status(self._request_manager)
+    self.teleoperation = Teleoperation(self._request_manager)
 
   @contextmanager
   def connection(self):

{standardbots-2.20240212.19 → standardbots-2.20240401.1}/standardbots/auto_generated/models.py

@@ -1032,6 +1032,44 @@ def serialize_runtime_variable(data: RuntimeVariable) -> object:
     "value": None if data.value is None else serialize_str(data.value),
   }
 
+SkillsList = List[str]
+
+def parse_skills_list(data: object) -> SkillsList:
+  return [parse_str(item) for item in data]
+
+def serialize_skills_list(data: SkillsList) -> List[object]:
+  return [serialize_str(item) for item in data]
+
+@dataclass
+class SpeechToTextRequest:
+  """Request to convert speech to text."""
+  encoded_audio_data: Union[str, None] = None
+
+  def validate_encoded_audio_data(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "encoded_audio_data must be of type str for SpeechToTextRequest, 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_encoded_audio_data(self.encoded_audio_data)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_speech_to_text_request(data: object):
+  return SpeechToTextRequest(
+    encoded_audio_data=parse_str(data["encoded_audio_data"]) if "encoded_audio_data" in data else None,
+  )
+
+def serialize_speech_to_text_request(data: SpeechToTextRequest) -> object:
+  return {
+    "encoded_audio_data": None if data.encoded_audio_data is None else serialize_str(data.encoded_audio_data),
+  }
+
 class StatusHealthEnum(Enum):
   Ok = "ok"
   """Enum Ok = `ok`"""
@@ -1091,6 +1129,56 @@ def serialize_status_version_data(data: StatusVersionData) -> object:
     "name": None if data.name is None else serialize_str(data.name),
   }
 
+class TeleopStateEnum(Enum):
+  WaitForTeleop = "wait_for_teleop"
+  """The system is waiting to start teleoperation."""
+  Teleop = "teleop"
+  """Teleoperation is active, and the robot is being controlled remotely."""
+  Stopping = "stopping"
+  """The robot is stopping."""
+  Stopped = "stopped"
+  """Teleoperation is stopped, and the robot is not moving."""
+  Moving = "moving"
+  """The robot is moving but not under teleoperation."""
+  Unfrozen = "unfrozen"
+  """The mini-arm is unfrozen."""
+
+def parse_teleop_state_enum(data: object) -> TeleopStateEnum:
+  return TeleopStateEnum(data)
+
+def serialize_teleop_state_enum(data: Union[TeleopStateEnum, str]) -> object:
+  return TeleopStateEnum(data).value
+
+@dataclass
+class TeleopStateUpdateRequest:
+  """Request to update the state of teleoperation to either start or stop."""
+  action: Union[str, None] = None
+
+  def validate_action(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "action must be of type str for TeleopStateUpdateRequest, got " + type(value).__name__]
+
+    return [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_teleop_state_update_request(data: object):
+  return TeleopStateUpdateRequest(
+    action=parse_str(data["action"]) if "action" in data else None,
+  )
+
+def serialize_teleop_state_update_request(data: TeleopStateUpdateRequest) -> object:
+  return {
+    "action": None if data.action is None else serialize_str(data.action),
+  }
+
 @dataclass
 class ArmPositionUpdateFailureEvent:
   """Move robot event when movement failed"""
@@ -1658,6 +1746,51 @@ def serialize_play_routine_request(data: PlayRoutineRequest) -> object:
     "variables": None if data.variables is None else serialize_routine_variables_state_map(data.variables),
   }
 
+@dataclass
+class TextToSkillRequest:
+  """Request to convert text to a skill."""
+  text: Union[str, None] = None
+  skills: Union[SkillsList, None] = None
+
+  def validate_text(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "text must be of type str for TextToSkillRequest, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_skills(self, value: SkillsList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, str) for x in value)):
+      return [False, "skills must be of type SkillsList for TextToSkillRequest, 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_text(self.text)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_skills(self.skills)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_text_to_skill_request(data: object):
+  return TextToSkillRequest(
+    text=parse_str(data["text"]) if "text" in data else None,
+    skills=parse_skills_list(data["skills"]) if "skills" in data else None,
+  )
+
+def serialize_text_to_skill_request(data: TextToSkillRequest) -> object:
+  return {
+    "text": None if data.text is None else serialize_str(data.text),
+    "skills": None if data.skills is None else serialize_skills_list(data.skills),
+  }
+
 @dataclass
 class StatusHealthResponse:
   """Status Health Response"""
@@ -1703,6 +1836,36 @@ def serialize_status_health_response(data: StatusHealthResponse) -> object:
     "build": None if data.build is None else serialize_status_version_data(data.build),
   }
 
+@dataclass
+class TeleopStateResponse:
+  """Response to a query for the current state of teleoperation."""
+  state: Union[TeleopStateEnum, None] = None
+
+  def validate_state(self, value: TeleopStateEnum) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not ((isinstance(value, str) and TeleopStateEnum in ['wait_for_teleop', 'teleop', 'stopping', 'stopped', 'moving', 'unfrozen']) or isinstance(value, TeleopStateEnum)):
+      return [False, "state must be of type TeleopStateEnum for TeleopStateResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_state(self.state)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_teleop_state_response(data: object):
+  return TeleopStateResponse(
+    state=parse_teleop_state_enum(data["state"]) if "state" in data else None,
+  )
+
+def serialize_teleop_state_response(data: TeleopStateResponse) -> object:
+  return {
+    "state": None if data.state is None else serialize_teleop_state_enum(data.state),
+  }
+
 @dataclass
 class ArmPositionUpdateRequestResponseEventStreamDetails:
   """Specify how the response should be sent

{standardbots-2.20240212.19 → standardbots-2.20240401.1}/standardbots.egg-info/PKG-INFO

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