standardbots 2.0.0.dev1744991656__tar.gz → 2.0.0.dev1744991699__tar.gz

{standardbots-2.0.0.dev1744991656 → standardbots-2.0.0.dev1744991699}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: standardbots
-Version: 2.0.0.dev1744991656
+Version: 2.0.0.dev1744991699
 Summary: Standard Bots RO1 Robotics API
 Home-page: 
 Author: Standard Bots Support

{standardbots-2.0.0.dev1744991656 → standardbots-2.0.0.dev1744991699}/README.md

@@ -24,6 +24,8 @@ To run a script move into the `sdks/python` folder and run `python playground/fi
 
 You may now use the `botctl` commands to setup and run tests.
 
+Set up the testing environment on the computer where you are running the tests:
+
 ```bash
 # Setup testing environment
 botctl publicapi test:setup --help
@@ -32,6 +34,11 @@ botctl publicapi test:setup --help
 botctl publicapi test --help
 ```
 
+Set up the bot environment on the robot:
+
+```bash
+botctl publicapi test:setup-bot
+```
 
 ## Setup
 
@@ -99,11 +106,8 @@ At start of testing, robot should:
 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.
+- You may pass a flag (e.g. `--camera-disconnected`) 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.
@@ -113,12 +117,12 @@ The basic idea here is:
 
 We use [pytest markers](https://docs.pytest.org/en/7.1.x/example/markers.html) to do this.
 
-#### Routine running
+#### Camera disconnected
 
-The special sample routine ("Test Public API") should be running prior to running these tests. Then do:
+The wrist camera should be disabled. Then run:
 
 ```bash
-python3 -m pytest ./tests --cov=standardbots --routine-running
+python3 -m pytest ./tests --cov=standardbots --camera-disconnected
 ```
 
 #### E-stop
@@ -162,5 +166,35 @@ To test custom sensors:
 Then run:
 
 ```bash
-python3 -m pytest ./tests --cov=standardbots --custom-sensors
+python3 -m pytest ./tests --cov=standardbots --gripper=custom_sensors
+```
+
+## Database backups
+
+> 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.
+
+### 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):
+
+```bash
+DB_USER=sb
+DB_NAME=sb
+BACKUP_FILE=$HOME/db-backup-publicapi-test.sql
+
+docker exec -it postgres-bot pg_dump -U $DB_USER -d $DB_NAME -F c -f /tmp/backup.sql
+
+docker cp postgres-bot:/tmp/backup.sql $BACKUP_FILE
+```
+
+If you need to download to the actual development environment:
+
+```bash
+CB_FILE=/home/control-box-bot/db-backup-publicapi-test.sql
+VM_FILE=~/sb/golang/apps/botctl/commands/publicapi/db-backup-publicapi-test.sql
+
+# Move directly to VM:
+scp cb2047:$CB_FILE $VM_FILE
 ```

{standardbots-2.0.0.dev1744991656 → standardbots-2.0.0.dev1744991699}/setup.py

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

{standardbots-2.0.0.dev1744991656 → standardbots-2.0.0.dev1744991699}/standardbots/auto_generated/apis.py

@@ -354,6 +354,368 @@ 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
+                )
+    class Payload:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def set_payload(
+            self,
+            body: models.PayloadStateRequest,
+        ) -> Response[
+            None,
+            None
+        ]:
+            """
+            Set a value for the mass being carried by the robot's end-effector.
+
+            """
+            path = "/api/v1/payload"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_payload_state_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_payload(
+            self,
+        ) -> Response[
+            Union[
+                models.PayloadStateResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.PayloadStateResponse
+        ]:
+            """
+            Get the current mass value being carried by the robot&#x27;s end-effector.
+
+            """
+            path = "/api/v1/payload"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_payload_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
+                )
+    class Recorder:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_recorder_state(
+            self,
+        ) -> Response[
+            Union[
+                models.RecorderState,
+                models.ErrorResponse,
+                None
+            ],
+            models.RecorderState
+        ]:
+            """
+            Get the state of the recorder
+            """
+            path = "/api/v1/recorder/state"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_recorder_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 update_recording(
+            self,
+            body: models.RecorderConfig,
+        ) -> Response[
+            Union[
+                models.UpdateRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.UpdateRecordingResponse
+        ]:
+            """
+            Update recording configuration
+            """
+            path = "/api/v1/recorder/update"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_recorder_config(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_update_recording_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 enable_recorder_bot(
+            self,
+            body: models.ToggleRecorderBotRequest,
+        ) -> Response[
+            Union[
+                models.UpdateRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.UpdateRecordingResponse
+        ]:
+            """
+            Enable or disable a secondary bot
+            """
+            path = "/api/v1/recorder/set-bot-enabled"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_toggle_recorder_bot_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_update_recording_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 start_recording(
+            self,
+            body: models.StartRecordingRequest,
+        ) -> Response[
+            Union[
+                models.StartRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StartRecordingResponse
+        ]:
+            """
+            Start recording movement and camera data
+            """
+            path = "/api/v1/recorder/start"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_start_recording_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_start_recording_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 stop_recording(
+            self,
+            body: models.StopRecordingRequest,
+        ) -> Response[
+            Union[
+                models.StopRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StopRecordingResponse
+        ]:
+            """
+            Stop recording movement and camera data
+            """
+            path = "/api/v1/recorder/stop"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_stop_recording_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_stop_recording_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 save_recording(
+            self,
+            body: models.SaveRecordingRequest,
+        ) -> Response[
+            Union[
+                models.SaveRecordingResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.SaveRecordingResponse
+        ]:
+            """
+            Save recording to marvin app
+            """
+            path = "/api/v1/recorder/save"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_save_recording_request(body)),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_save_recording_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,
@@ -470,18 +832,203 @@ class Default:
                     503,
                     None
                 )
+    class Teleop:
+        def __init__(self, request_manager: RequestManager):
+            self._request_manager = request_manager
+
+
+        def get_state(
+            self,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Get the state of the teleop
+            """
+            path = "/api/v1/teleop/state"
+            try:
+                response = self._request_manager.request(
+                    "GET",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                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 enable_bot(
+            self,
+            body: models.ToggleTeleopBotRequest,
+        ) -> Response[
+            Union[
+                models.TeleopState,
+                models.ErrorResponse,
+                None
+            ],
+            models.TeleopState
+        ]:
+            """
+            Enable or disable a secondary bot
+            """
+            path = "/api/v1/teleop/set-bot-enabled"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                    body=json.dumps(models.serialize_toggle_teleop_bot_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 start_teleop(
+            self,
+        ) -> Response[
+            Union[
+                models.StartTeleopResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StartTeleopResponse
+        ]:
+            """
+            Start teleoperation
+            """
+            path = "/api/v1/teleop/start"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_start_teleop_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 stop_teleop(
+            self,
+        ) -> Response[
+            Union[
+                models.StopTeleopResponse,
+                models.ErrorResponse,
+                None
+            ],
+            models.StopTeleopResponse
+        ]:
+            """
+            Stop recording movement and camera data
+            """
+            path = "/api/v1/teleop/stop"
+            try:
+                response = self._request_manager.request(
+                    "POST",
+                    path,
+                    headers=self._request_manager.json_headers(),
+                )
+                parsed = None
+                if response.status == 200:
+                    parsed = models.parse_stop_teleop_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
+    payload: Payload
+    recorder: Recorder
     sensors: Sensors
     space: Space
+    teleop: Teleop
 
     def __init__(self, request_manager: RequestManager):
         self._request_manager = request_manager
         self.calibration = Default.Calibration(request_manager)
         self.equipment = Default.Equipment(request_manager)
+        self.payload = Default.Payload(request_manager)
+        self.recorder = Default.Recorder(request_manager)
         self.sensors = Default.Sensors(request_manager)
         self.space = Default.Space(request_manager)
+        self.teleop = Default.Teleop(request_manager)
 
 class Movement:
     _request_manager: RequestManager