standardbots 2.20250512.49__py3-none-any.whl → 2.20250801.2__py3-none-any.whl

standardbots/auto_generated/apis.py

@@ -284,6 +284,50 @@ class Default:
             )
         
 
+        def get_equipment(
+            self,
+        ) -> Response[
+            Union[
+                models.GetEquipmentConfigResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.GetEquipmentConfigResponse
+        ]:
+            """
+            Get the currently-configured equipment
+
+            """
+            path = "/api/v1/equipment"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_get_equipment_config_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
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
         def control_gripper(
             self,
             body: models.GripperCommandRequest,
@@ -1107,6 +1151,99 @@ class Default:
                     503,
                     None
                 )
+    class Webrtc:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def send_message(
+            self,
+            body: models.SendMessageRequest,
+        ) -> Response[
+            None,
+            None
+        ]:
+            """
+            Send a WebRTC signaling message
+            """
+            path = "/api/v1/webrtc/message"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_send_message_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
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def get_messages(
+            self,
+            base_url: str,
+            client_id: str,
+        ) -> Response[
+            Union[
+                models.GetMessagesResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.GetMessagesResponse
+        ]:
+            """
+            Get pending WebRTC signaling messages
+            """
+            path = "/api/v1/webrtc/messages"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    fields={
+                        "baseUrl": models.serialize_str(base_url),
+                        "clientId": models.serialize_str(client_id),
+                    }
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_get_messages_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
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
 
     calibration: Calibration
     equipment: Equipment
@@ -1115,6 +1252,7 @@ class Default:
     sensors: Sensors
     space: Space
     teleop: Teleop
+    webrtc: Webrtc
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
@@ -1125,6 +1263,7 @@ class Default:
         self.sensors = Default.Sensors(request_manager)
         self.space = Default.Space(request_manager)
         self.teleop = Default.Teleop(request_manager)
+        self.webrtc = Default.Webrtc(request_manager)
 
 class Movement:
     _request_manager: RequestManager
@@ -1753,16 +1892,66 @@ class Camera:
                     503,
                     None
                 )
+    class Bot:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_connected_cameras(
+            self,
+        ) -> Response[
+            Union[
+                models.CameraDeviceList,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraDeviceList
+        ]:
+            """
+            Retrieve the list of connected camera devices from camera bot.
+            """
+            path = "/api/v1/cameras/connected"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_device_list(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
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
 
     data: Data
     settings: Settings
     status: Status
+    bot: Bot
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
         self.data = Camera.Data(request_manager)
         self.settings = Camera.Settings(request_manager)
         self.status = Camera.Status(request_manager)
+        self.bot = Camera.Bot(request_manager)
 
 class Faults:
     _request_manager: RequestManager
@@ -2135,6 +2324,112 @@ class IO:
         self.control = IO.Control(request_manager)
         self.status = IO.Status(request_manager)
 
+class Messenger:
+    _request_manager: RequestManager
+    class Peers:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def register_peer(
+            self,
+            body: models.RegisterPeerRequest,
+        ) -> Response[
+            Union[
+                models.RegisterPeerResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.RegisterPeerResponse
+        ]:
+            """
+            Register a new peer with the messenger system.
+
+            """
+            path = "/api/v1/messenger/peers"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_register_peer_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_register_peer_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
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+        def unregister_peer(
+            self,
+            body: models.UnregisterPeerRequest,
+        ) -> Response[
+            Union[
+                models.UnregisterPeerResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.UnregisterPeerResponse
+        ]:
+            """
+            Unregister an existing peer from the messenger system.
+
+            """
+            path = "/api/v1/messenger/peers"
+            try:
+                response = self._request_manager.request(
+                    "DELETE",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_unregister_peer_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_unregister_peer_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
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+
+    peers: Peers
+
+    def __init__(self, request_manager: RequestManager):
+        self._request_manager = request_manager
+        self.peers = Messenger.Peers(request_manager)
+
 class Poses:
     _request_manager: RequestManager
     class ConstructPose:
@@ -3459,6 +3754,7 @@ class StandardBotsRobot(Default):
     general: General
     chat_gpt: ChatGPT
     io: IO
+    messenger: Messenger
     poses: Poses
     recovery: Recovery
     ros: ROS
@@ -3483,6 +3779,7 @@ class StandardBotsRobot(Default):
         self.general = General(self._request_manager)
         self.chat_gpt = ChatGPT(self._request_manager)
         self.io = IO(self._request_manager)
+        self.messenger = Messenger(self._request_manager)
         self.poses = Poses(self._request_manager)
         self.recovery = Recovery(self._request_manager)
         self.ros = ROS(self._request_manager)