standardbots 2.20250512.15__tar.gz → 2.20250923.36__tar.gz

{standardbots-2.20250512.15 → standardbots-2.20250923.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: standardbots
-Version: 2.20250512.15
+Version: 2.20250923.36
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.20250512.15 → standardbots-2.20250923.36}/README.md

@@ -1,9 +1,11 @@
-You can test the API by using the playground, add your own file or use the existing python scripts.
-When a client has an issue, and they send their code. It's helpful to test their code to see possible issues
+You can test the API by using the playground, add your own file or use the
+existing python scripts. When a client has an issue, and they send their code.
+It's helpful to test their code to see possible issues
 
 # ENABLE API ON YOUR LOCAL MACHINE
 
-Follow the steps here https://www.notion.so/standardbots/Using-the-REST-API-b2c778d47969444dac61483f0117acad
+Follow the steps here
+https://www.notion.so/standardbots/Using-the-REST-API-b2c778d47969444dac61483f0117acad
 
 # CONFIG
 
@@ -11,7 +13,8 @@ At the top of the file, use your token
 
 # RUN
 
-To run a script move into the `sdks/python` folder and run `python playground/filename.py`
+To run a script move into the `sdks/python` folder and run
+`python playground/filename.py`
 
 # To create a test build
 
@@ -48,8 +51,8 @@ To set up tests:
 cd sdks/python
 ```
 
-Note: Make sure to select proper python interpreter.
-Sometimes there is an error related to missing "dotenv" module, to solve this install it separately
+Note: Make sure to select proper python interpreter. Sometimes there is an error
+related to missing "dotenv" module, to solve this install it separately
 
 ```
 python3 -m pip install python-dotenv
@@ -60,16 +63,18 @@ python3 -m pip install -r requirements-dev.txt
 
 #### Sample routine
 
-You need to add the sample routine in [sdks/python/tests/fixtures/test_public_api_routine.json](./tests/fixtures/test_public_api_routine.json) to your target test environment (i.e. upload the routine to ).
+You need to add the sample routine in
+[sdks/python/tests/fixtures/test_public_api_routine.json](./tests/fixtures/test_public_api_routine.json)
+to your target test environment (i.e. upload the routine to ).
 
 The name of routine should be "Test Public API"
 
 #### Sample globals
 
-- _Variable._ Add global variable called "test_public_api_global" with any value.
+- _Variable._ Add global variable called "test_public_api_global" with any
+  value.
 - _Space._ Create a global space called "Test global space" of any kind.
 
-
 ## Running
 
 Here is a basic test command:
@@ -81,7 +86,8 @@ SB_API_TOKEN=...
 python3 -m pytest ./tests --cov=standardbots --token=$SB_API_TOKEN --api-url=$SB_API_URL
 ```
 
-You may also set up a `.env` file at `sdks/python/.env` with the following contents:
+You may also set up a `.env` file at `sdks/python/.env` with the following
+contents:
 
 ```bash
 export SB_API_URL=http://34.162.0.32:3000
@@ -96,38 +102,43 @@ python3 -m pytest ./tests --cov=standardbots
 
 ### Robot state and testing (Markers)
 
-We need the bot to be in a certain state to run certain tests. For example, we need a routine to be running in order to stop the routine. Camera should be connected by default.
+We need the bot to be in a certain state to run certain tests. For example, we
+need a routine to be running in order to stop the routine. Camera should be
+disconnected by default.
 
 At start of testing, robot should:
 
 - _NOT_ be e-stopped.
 
-
 The basic idea here is:
 
 - These special tests will not be run by default.
-- You may pass a flag (e.g. `--camera-disconnected`) when the bot is in the correct state to run the tests.
+- You may pass a flag (e.g. `--camera-connected`) when the bot is in the correct
+  state to run the tests.
 - Markers usage:
-- When `--gripper=<type>` flag is passed(`type` is value from `GripperKindEnum` enum):
+- When `--gripper=<type>` flag is passed(`type` is value from `GripperKindEnum`
+  enum):
   1. Tests expect that this specific gripper is connected
   2. Tests without the flag are not run.
-- When `--camera-disconnected` flag is passed:
+- When `--camera-connected` flag is passed:
   1. Tests with the flag are run.
   2. Tests without the flag are not run.
 
-We use [pytest markers](https://docs.pytest.org/en/7.1.x/example/markers.html) to do this.
+We use [pytest markers](https://docs.pytest.org/en/7.1.x/example/markers.html)
+to do this.
 
 #### Camera disconnected
 
 The wrist camera should be disabled. Then run:
 
 ```bash
-python3 -m pytest ./tests --cov=standardbots --camera-disconnected
+python3 -m pytest ./tests --cov=standardbots --camera-connected
 ```
 
 #### E-stop
 
-No marker needed for e-stop. However, we do rely on active recovery of e-stop and getting the failure state in order to do these tests.
+No marker needed for e-stop. However, we do rely on active recovery of e-stop
+and getting the failure state in order to do these tests.
 
 When e-stop test runs, cannot have bot in a failure state (pre-test will fail).
 
@@ -151,16 +162,19 @@ tests/test_apis.py
 Fixes:
 
 - _Make sure you can log into remote control._ Ensure that botman is connected.
-- _Ensure that the robot URL is up-to-date._ Botman url will often change when you reboot.
+- _Ensure that the robot URL is up-to-date._ Botman url will often change when
+  you reboot.
 
 ### Custom sensors
 
 To test custom sensors:
+
 - go to the menu on the left bottom corner;
 - Click on 'Equipment';
 - Add Gripper > Custom Gripper;
 - Go to the Sensors tab and click 'Add Sensor';
-- Keep the default values as they are (name: 'Sensor 1', kind: 'Control Box IO', sensor value: 'low');
+- Keep the default values as they are (name: 'Sensor 1', kind: 'Control Box IO',
+  sensor value: 'low');
 - Hit 'Save' and make sure the Custom Gripper is enabled.
 
 Then run:
@@ -173,11 +187,13 @@ python3 -m pytest ./tests --cov=standardbots --gripper=custom_sensors
 
 > See command: `botctl publicapi test:setup-bot`.
 
-We now have a common robot database state that can be used for testing. While this isn't necessary for use, it does provide a common state for testing.
+We now have a common robot database state that can be used for testing. While
+this isn't necessary for use, it does provide a common state for testing.
 
 ### How to create a new backup
 
-In the place where you are running the stack and want to create the backup (e.g. on the control box):
+In the place where you are running the stack and want to create the backup (e.g.
+on the control box):
 
 ```bash
 DB_USER=sb

{standardbots-2.20250512.15 → standardbots-2.20250923.36}/setup.py

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

{standardbots-2.20250512.15 → standardbots-2.20250923.36}/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,
@@ -1074,7 +1118,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:
@@ -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)