standardbots 2.0.0.dev1744991699__tar.gz → 2.0.0.dev1745245900__tar.gz

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

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

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

@@ -24,8 +24,6 @@ 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
@@ -34,11 +32,6 @@ botctl publicapi test:setup --help
 botctl publicapi test --help
 ```
 
-Set up the bot environment on the robot:
-
-```bash
-botctl publicapi test:setup-bot
-```
 
 ## Setup
 
@@ -106,8 +99,11 @@ 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. `--camera-disconnected`) when the bot is in the correct state to run the tests.
+- 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.
@@ -117,12 +113,12 @@ The basic idea here is:
 
 We use [pytest markers](https://docs.pytest.org/en/7.1.x/example/markers.html) to do this.
 
-#### Camera disconnected
+#### Routine running
 
-The wrist camera should be disabled. Then run:
+The special sample routine ("Test Public API") should be running prior to running these tests. Then do:
 
 ```bash
-python3 -m pytest ./tests --cov=standardbots --camera-disconnected
+python3 -m pytest ./tests --cov=standardbots --routine-running
 ```
 
 #### E-stop
@@ -166,35 +162,5 @@ To test custom sensors:
 Then run:
 
 ```bash
-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
+python3 -m pytest ./tests --cov=standardbots --custom-sensors
 ```

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

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

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

@@ -354,368 +354,6 @@ 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,
@@ -832,203 +470,18 @@ 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