standardbots 2.0.0.dev1760378411__py3-none-any.whl → 2.0.0.dev1768505129__py3-none-any.whl

standardbots/auto_generated/apis.py

@@ -833,6 +833,49 @@ class Default:
             self._request_manager = request_manager
 
 
+        def list_global_spaces(
+            self,
+        ) -> Response[
+            Union[
+                models.SpacesPaginatedResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.SpacesPaginatedResponse
+        ]:
+            """
+            List Global Spaces
+            """
+            path = "/api/v1/space/globals"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_spaces_paginated_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 list_planes(
             self,
             limit: int,
@@ -889,6 +932,7 @@ class Default:
 
         def get_state(
             self,
+            client_id: str,
         ) -> Response[
             Union[
                 models.TeleopState,
@@ -906,6 +950,9 @@ class Default:
                     "GET",
                     path,
                     headers=self._request_manager.json_headers(),
+                    fields={
+                        "client_id": models.serialize_str(client_id),
+                    }
                 )
                 parsed = None
                 if response.status == 200:
@@ -1022,6 +1069,8 @@ class Default:
                 )
         def start_teleop(
             self,
+            client_id: str,
+            secondary_client_id: str,
         ) -> Response[
             Union[
                 models.StartTeleopResponse,
@@ -1039,6 +1088,10 @@ class Default:
                     "POST",
                     path,
                     headers=self._request_manager.json_headers(),
+                    fields={
+                        "client_id": models.serialize_str(client_id),
+                        "secondary_client_id": models.serialize_str(secondary_client_id),
+                    }
                 )
                 parsed = None
                 if response.status == 200:
@@ -1065,6 +1118,9 @@ class Default:
                 )
         def stop_teleop(
             self,
+            client_id: str,
+            secondary_client_id: str,
+            force: bool,
         ) -> Response[
             Union[
                 models.StopTeleopResponse,
@@ -1082,6 +1138,11 @@ class Default:
                     "POST",
                     path,
                     headers=self._request_manager.json_headers(),
+                    fields={
+                        "client_id": models.serialize_str(client_id),
+                        "secondary_client_id": models.serialize_str(secondary_client_id),
+                        "force": models.serialize_bool(force),
+                    }
                 )
                 parsed = None
                 if response.status == 200:
@@ -1118,7 +1179,7 @@ class Default:
             models.TeleopState
         ]:
             """
-            Set ratio control parameters
+            Set ratio control parameters for movement and rotation
             """
             path = "/api/v1/teleop/set-ratio-control"
             try:
@@ -1137,6 +1198,186 @@ class Default:
                 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 set_gripper_bounds(
+            self,
+            body: models.SetGripperBoundsRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set gripper bounds for primary and secondary bots
+            """
+            path = "/api/v1/teleop/set-gripper-bounds"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_set_gripper_bounds_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(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 set_robot_frame(
+            self,
+            body: models.SetRobotFrameRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set robot frame
+            """
+            path = "/api/v1/teleop/set-robot-frame"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_set_robot_frame_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(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 set_bolt_head_position(
+            self,
+            body: models.SetBoltHeadPositionRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set static bolt head position
+            """
+            path = "/api/v1/teleop/set-bolt-head-position"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_set_bolt_head_position_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(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 set_filter_type(
+            self,
+            body: models.SetFilterTypeRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Set filter type
+            """
+            path = "/api/v1/teleop/set-filter-type"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_set_filter_type_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_teleop_state(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,
@@ -1781,6 +2022,55 @@ class Camera:
                 )
                 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_camera_frame(
+            self,
+            camera_id: str,
+            stream_name: str,
+        ) -> Response[
+            Union[
+                models.CameraFrameResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraFrameResponse
+        ]:
+            """
+            Retrieve the latest frame from a specific camera by camera ID using the messenger GetFrame method. Returns a JSON object containing the frame as a base64 string in JPEG format, along with frame metadata including timestamp, camera ID, and stream name.
+            """
+            path = "/api/v1/camera/{camera_id}/frame"
+            path = path.replace("{camera_id}", str(camera_id))
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    fields={
+                        "stream_name": models.serialize_str(stream_name),
+                    }
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_frame_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):