standardbots 2.20241120.1__tar.gz → 2.20250128.2__tar.gz

{standardbots-2.20241120.1 → standardbots-2.20250128.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: standardbots
-Version: 2.20241120.1
+Version: 2.20250128.2
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support
@@ -10,6 +10,13 @@ Requires-Python: >=3.7
 Requires-Dist: setuptools>=21.0.0
 Requires-Dist: typing_extensions>=4.3.0
 Requires-Dist: urllib3>=1.26.7
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
     Standard Bots RO1 Robotics API.  # noqa: E501
     

standardbots-2.20250128.2/README.md

@@ -0,0 +1,141 @@
+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
+
+pip install -r requirements.txt
+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.
+
+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.
+- When the 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.20241120.1 → standardbots-2.20250128.2}/setup.py

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

{standardbots-2.20241120.1 → standardbots-2.20250128.2}/standardbots/auto_generated/apis.py

@@ -76,6 +76,55 @@ 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.ActiveCalibrationResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.ActiveCalibrationResponse
+        ]:
+            """
+            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_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
+                )
     class Equipment:
         def __init__(self, request_manager: RequestManager):
             self._request_manager = request_manager
@@ -188,7 +237,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 +431,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)
@@ -713,7 +764,7 @@ class Camera:
             None
         ]:
             """
-            Retrieve the latest RGB frame from the camera.
+            Retrieve the latest RGB frame from the camera. In JPEG format.
             """
             path = "/api/v1/camera/frame/rgb"
             try:
@@ -932,6 +983,113 @@ class Faults:
         self._request_manager = request_manager
         self.user_faults = Faults.UserFaults(request_manager)
 
+class General:
+    _request_manager: RequestManager
+    class BotIdentity:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def bot_identity(
+            self,
+        ) -> Response[
+            Union[
+                models.BotIdentityData,
+                models.ErrorResponse,
+                None
+            ],
+            models.BotIdentityData
+        ]:
+            """
+            Get information about the robot&#x27;s identity.
+            """
+            path = "/api/v1/identity/bot_identity"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_bot_identity_data(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
+                )
+    class Joints:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_joints_state(
+            self,
+        ) -> Response[
+            Union[
+                models.JointsStateResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.JointsStateResponse
+        ]:
+            """
+            Retrieves information about the state of each joint
+            """
+            path = "/api/v1/joints"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_joints_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
+                )
+            except urllib3.exceptions.MaxRetryError:
+                return Response(
+                    models.ErrorResponse(
+                        error=models.ErrorEnum.InternalServerError,
+                        message="Connection Refused"
+                    ),
+                    503,
+                    None
+                )
+
+    bot_identity: BotIdentity
+    joints: Joints
+
+    def __init__(self, request_manager: RequestManager):
+        self._request_manager = request_manager
+        self.bot_identity = General.BotIdentity(request_manager)
+        self.joints = General.Joints(request_manager)
+
 class ChatGPT:
     _request_manager: RequestManager
     class Data:
@@ -1136,63 +1294,6 @@ class IO:
         self.control = IO.Control(request_manager)
         self.status = IO.Status(request_manager)
 
-class General:
-    _request_manager: RequestManager
-    class Joints:
-        def __init__(self, request_manager: RequestManager):
-            self._request_manager = request_manager
-
-
-        def get_joints_state(
-            self,
-        ) -> Response[
-            Union[
-                models.JointsStateResponse,
-                models.ErrorResponse,
-                None
-            ],
-            models.JointsStateResponse
-        ]:
-            """
-            Retrieves information about the state of each joint
-            """
-            path = "/api/v1/joints"
-            try:
-                response = self._request_manager.request(
-                    "GET",
-                    path,
-                    headers=self._request_manager.json_headers(),
-                )
-                parsed = None
-                if response.status == 200:
-                    parsed = models.parse_joints_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
-                )
-            except urllib3.exceptions.MaxRetryError:
-                return Response(
-                    models.ErrorResponse(
-                        error=models.ErrorEnum.InternalServerError,
-                        message="Connection Refused"
-                    ),
-                    503,
-                    None
-                )
-
-    joints: Joints
-
-    def __init__(self, request_manager: RequestManager):
-        self._request_manager = request_manager
-        self.joints = General.Joints(request_manager)
-
 class Poses:
     _request_manager: RequestManager
     class ConstructPose:
@@ -1662,15 +1763,15 @@ class Recovery:
             self,
         ) -> Response[
             Union[
-                models.RecoveryStatusResponse,
+                models.FailureStateResponse,
                 models.ErrorResponse,
                 models.ErrorResponse,
                 None
             ],
-            models.RecoveryStatusResponse
+            models.FailureStateResponse
         ]:
             """
-            Recovers the robot from a fault state.
+            Attempts to recover the robot from a fault state. Inspect the response to determine if additional recovery actions are required.
 
             """
             path = "/api/v1/recovery/recover"
@@ -1682,7 +1783,7 @@ class Recovery:
                 )
                 parsed = None
                 if response.status == 200:
-                    parsed = models.parse_recovery_status_response(json.loads(response.data))
+                    parsed = models.parse_failure_state_response(json.loads(response.data))
                 if response.status == 400:
                     parsed = models.parse_error_response(json.loads(response.data))
 
@@ -2493,9 +2594,9 @@ class StandardBotsRobot(Default):
     movement: Movement
     camera: Camera
     faults: Faults
+    general: General
     chat_gpt: ChatGPT
     io: IO
-    general: General
     poses: Poses
     recovery: Recovery
     ros: ROS
@@ -2517,9 +2618,9 @@ class StandardBotsRobot(Default):
         self.movement = Movement(self._request_manager)
         self.camera = Camera(self._request_manager)
         self.faults = Faults(self._request_manager)
+        self.general = General(self._request_manager)
         self.chat_gpt = ChatGPT(self._request_manager)
         self.io = IO(self._request_manager)
-        self.general = General(self._request_manager)
         self.poses = Poses(self._request_manager)
         self.recovery = Recovery(self._request_manager)
         self.ros = ROS(self._request_manager)