standardbots 2.0.0.dev1737138088__tar.gz → 2.0.0.dev1740502639__tar.gz

{standardbots-2.0.0.dev1737138088 → standardbots-2.0.0.dev1740502639}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: standardbots
-Version: 2.0.0.dev1737138088
+Version: 2.0.0.dev1740502639
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

standardbots-2.0.0.dev1740502639/README.md

@@ -0,0 +1,153 @@
+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
+
+# CONFIG
+
+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 create a test build
+
+1. Update version in `setup.py`
+2. Run `python3 setup.py sdist bdist_wheel`
+
+# Tests
+
+## Setup
+
+To set up tests:
+
+```bash
+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
+
+```
+python3 -m pip install python-dotenv
+python3 -m pip install -r requirements-dev.txt
+```
+
+### Create sample data
+
+#### 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 ).
+
+The name of routine should be "Test Public API"
+
+#### Sample globals
+
+- _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:
+
+```bash
+SB_API_URL=http://34.162.0.32:3000
+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:
+
+```bash
+export SB_API_URL=http://34.162.0.32:3000
+export SB_API_TOKEN=...
+```
+
+Then you can just do:
+
+```bash
+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.
+
+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. `--routine-running`) when the bot is in the correct state to run the tests.
+- Markers usage:
+- When `--routine-running` flag is passed:
+  1. Tests with the flag are run.
+  2. Tests without the flag are not run.
+- 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:
+  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.
+
+#### Routine running
+
+The special sample routine ("Test Public API") should be running prior to running these tests. Then do:
+
+```bash
+python3 -m pytest ./tests --cov=standardbots --routine-running
+```
+
+#### 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.
+
+When e-stop test runs, cannot have bot in a failure state (pre-test will fail).
+
+## Troubleshooting
+
+### Tests are hanging
+
+The first test appears to start but then nothing happens for several seconds:
+
+```bash
+$ python3 -m pytest ./tests --cov=standardbots
+========================================================================================================== test session starts ===========================================================================================================
+platform linux -- Python 3.10.12, pytest-6.2.5, py-1.10.0, pluggy-0.13.0
+rootdir: /workspaces/sb/sdks/python, configfile: pytest.ini
+plugins: ament-pep257-0.12.11, ament-xmllint-0.12.11, launch-testing-1.0.6, launch-testing-ros-0.19.7, ament-flake8-0.12.11, ament-lint-0.12.11, ament-copyright-0.12.11, colcon-core-0.18.1, cov-6.0.0
+collected 110 items
+
+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.
+
+### 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');
+- Hit 'Save' and make sure the Custom Gripper is enabled.
+
+Then run:
+
+```bash
+python3 -m pytest ./tests --cov=standardbots --custom-sensors
+```

{standardbots-2.0.0.dev1737138088 → standardbots-2.0.0.dev1740502639}/setup.py

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

{standardbots-2.0.0.dev1737138088 → standardbots-2.0.0.dev1740502639}/standardbots/auto_generated/apis.py

@@ -76,6 +76,95 @@ class RequestManager:
 
 class Default:
     _request_manager: RequestManager
+    class Calibration:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_active_calibration(
+            self,
+        ) -> Response[
+            Union[
+                models.ActiveCalibrationContainer,
+                models.ErrorResponse,
+                None
+            ],
+            models.ActiveCalibrationContainer
+        ]:
+            """
+            Get the active calibration for the robot.
+
+            """
+            path = "/api/v1/calibration/active"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_active_calibration_container(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_active_calibration(
+            self,
+            body: models.ActiveCalibrationContainer,
+        ) -> Response[
+            None,
+            None
+        ]:
+            """
+            Set the active calibration for the robot.
+
+            """
+            path = "/api/v1/calibration/active"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_active_calibration_container(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
+                )
     class Equipment:
         def __init__(self, request_manager: RequestManager):
             self._request_manager = request_manager
@@ -83,7 +172,7 @@ class Default:
         def onrobot_2fg7_move(
           self,
           value: Union[int, float],
-          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Inward,
+          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Internal,
           unit_kind: Union[str, models.LinearUnitKind] = models.LinearUnitKind.Millimeters
         ):
           """Move the robot to the onrobot_2fg7 position.
@@ -105,7 +194,7 @@ class Default:
         def onrobot_2fg7_grip(
           self,
           value: Union[int, float],
-          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Inward,
+          direction: Union[str, models.LinearGripDirectionEnum] = models.LinearGripDirectionEnum.Internal,
           unit_kind: Union[str, models.LinearUnitKind] = models.LinearUnitKind.Millimeters,
           force: Union[int, float] = 0.0,
           force_unit: Union[str, models.ForceUnitKind] = models.ForceUnitKind.Newtons
@@ -188,7 +277,7 @@ class Default:
             return self.control_gripper(
                 body=models.GripperCommandRequest(
                     kind=models.GripperKindEnum.DhCgi,
-                    dh_pgc=models.DHCGIGripperCommandRequest(
+                    dh_cgi=models.DHCGIGripperCommandRequest(
                         target_diameter, target_force, target_speed
                     ),
                 ),
@@ -382,12 +471,14 @@ class Default:
                     None
                 )
 
+    calibration: Calibration
     equipment: Equipment
     sensors: Sensors
     space: Space
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
+        self.calibration = Default.Calibration(request_manager)
         self.equipment = Default.Equipment(request_manager)
         self.sensors = Default.Sensors(request_manager)
         self.space = Default.Space(request_manager)
@@ -425,6 +516,7 @@ class Movement:
             Union[
                 models.BrakesState,
                 models.ErrorResponse,
+                models.ErrorResponse,
                 None
             ],
             models.BrakesState
@@ -444,6 +536,8 @@ class Movement:
                 parsed = None
                 if response.status == 200:
                     parsed = models.parse_brakes_state(json.loads(response.data))
+                if response.status == 500:
+                    parsed = models.parse_error_response(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -713,7 +807,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera.
+            Retrieve the latest RGB frame from the camera as base64 string. In JPEG format.
             """
             path = "/api/v1/camera/frame/rgb"
             try:
@@ -747,8 +841,12 @@ class Camera:
         def get_camera_intrinsics_color(
             self,
         ) -> Response[
-            None,
-            None
+            Union[
+                models.CameraIntrinsics,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraIntrinsics
         ]:
             """
             Retrieve the intrinsic parameters for the color camera.
@@ -761,6 +859,8 @@ class Camera:
                     headers=self._request_manager.json_headers(),
                 )
                 parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_intrinsics(json.loads(response.data))
 
                 is_user_error = response.status >= 400 and response.status <= 500
                 is_unavailable = response.status == 503
@@ -788,7 +888,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera.
+            Retrieve the latest RGB frame from the camera as base64 string. In JPEG format.
             """
             path = "/api/v1/camera/stream/rgb"
             try:
@@ -863,14 +963,64 @@ class Camera:
                     503,
                     None
                 )
+    class Status:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_camera_status(
+            self,
+        ) -> Response[
+            Union[
+                models.CameraStatus,
+                models.ErrorResponse,
+                None
+            ],
+            models.CameraStatus
+        ]:
+            """
+            Retrieve the current status of the camera.
+            """
+            path = "/api/v1/camera/status"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_camera_status(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
 
     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)
 
 class Faults:
     _request_manager: RequestManager
@@ -1927,8 +2077,13 @@ class RoutineEditor:
             body: models.PlayRoutineRequest,
             routine_id: str,
         ) -> Response[
-            None,
-            None
+            Union[
+                models.PlayRoutineResponse,
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.PlayRoutineResponse
         ]:
             """
             Play a routine
@@ -1943,6 +2098,10 @@ class RoutineEditor:
                     body=json.dumps(models.serialize_play_routine_request(body)),
                 )
                 parsed = None
+                if response.status == 200:
+                    parsed = models.parse_play_routine_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
@@ -1967,11 +2126,15 @@ class RoutineEditor:
             self,
             routine_id: str,
         ) -> Response[
-            None,
+            Union[
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
             None
         ]:
             """
-            Pause a routine
+            Pause a routine. Routine must be running.
             """
             path = "/api/v1/routine-editor/routines/{routine_id}/pause"
             path = path.replace("{routine_id}", str(routine_id))
@@ -1982,6 +2145,8 @@ class RoutineEditor:
                     headers=self._request_manager.json_headers(),
                 )
                 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
@@ -2005,11 +2170,15 @@ class RoutineEditor:
         def stop(
             self,
         ) -> Response[
-            None,
+            Union[
+                models.ErrorResponse,
+                models.ErrorResponse,
+                None
+            ],
             None
         ]:
             """
-            Stop running routine and all ongoing motions
+            Stop running routine and all ongoing motions. Routine must be running.
             """
             path = "/api/v1/routine-editor/stop"
             try:
@@ -2019,6 +2188,8 @@ class RoutineEditor:
                     headers=self._request_manager.json_headers(),
                 )
                 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
@@ -2293,7 +2464,7 @@ class RoutineEditor:
             models.RuntimeVariable
         ]:
             """
-            Returns current state of a variable
+            Returns current state of a variable. Routine must be running.
             """
             path = "/api/v1/routine-editor/variables/{variable_name}"
             path = path.replace("{variable_name}", str(variable_name))
@@ -2339,7 +2510,7 @@ class RoutineEditor:
             models.RuntimeVariable
         ]:
             """
-            Update the value of a variable
+            Update the value of a variable. Routine must be running.
             """
             path = "/api/v1/routine-editor/variables/{variable_name}"
             path = path.replace("{variable_name}", str(variable_name))