standardbots 2.0.0.dev1751305397__py3-none-any.whl → 2.0.1__py3-none-any.whl

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,

standardbots/auto_generated/models.py

@@ -1186,18 +1186,106 @@ def serialize_environment_variable(data: EnvironmentVariable) -> object:
   }
 
 @dataclass
-class EquipmentKeyAssignments:
-  """Dictionary mapping equipment IDs to equipment keys"""
+class EquipmentConfig:
+  """Equipment configuration
+"""
+  id: Union[str, None] = None
+  name: Union[str, None] = None
+  kind: Union[str, None] = None
+  is_enabled: Union[bool, None] = None
+  config: Union[str, None] = None
+
+  def validate_id(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "id is required for EquipmentConfig"]
+
+    if not isinstance(value, str):
+      return [False, "id must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_name(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not isinstance(value, str):
+      return [False, "name must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_kind(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "kind is required for EquipmentConfig"]
+
+    if not isinstance(value, str):
+      return [False, "kind must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_is_enabled(self, value: bool) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "is_enabled is required for EquipmentConfig"]
+
+    if not isinstance(value, bool):
+      return [False, "is_enabled must be of type bool for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def validate_config(self, value: str) -> Tuple[bool, str]:
+    if value is None:
+      return [False, "config is required for EquipmentConfig"]
+
+    if not isinstance(value, str):
+      return [False, "config must be of type str for EquipmentConfig, got " + type(value).__name__]
+
+    return [True, ""]
 
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_id(self.id)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_name(self.name)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_kind(self.kind)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_is_enabled(self.is_enabled)
+    if not is_valid:
+      raise TypeError(error_str)
+    is_valid, error_str = self.validate_config(self.config)
+    if not is_valid:
+      raise TypeError(error_str)
 
-def parse_equipment_key_assignments(data: object):
-  return EquipmentKeyAssignments(
+def parse_equipment_config(data: object):
+  return EquipmentConfig(
+    id=parse_str(data["id"]) if "id" in data and data.get("id") is not None else None,
+    name=parse_str(data["name"]) if "name" in data and data.get("name") is not None else None,
+    kind=parse_str(data["kind"]) if "kind" in data and data.get("kind") is not None else None,
+    is_enabled=parse_bool(data["is_enabled"]) if "is_enabled" in data and data.get("is_enabled") is not None else None,
+    config=parse_str(data["config"]) if "config" in data and data.get("config") is not None else None,
   )
 
+def serialize_equipment_config(data: EquipmentConfig) -> object:
+  return {
+    "id": serialize_str(data.id),
+    "name": None if data.name is None else serialize_str(data.name),
+    "kind": serialize_str(data.kind),
+    "is_enabled": serialize_bool(data.is_enabled),
+    "config": serialize_str(data.config),
+  }
+
+EquipmentKeyAssignments = Dict[str, str]
+
+def parse_equipment_key_assignments(data: object) -> EquipmentKeyAssignments:
+  return {
+    parse_str(key): parse_str(value) for key, value in data.items()
+  }
+
 def serialize_equipment_key_assignments(data: EquipmentKeyAssignments) -> object:
   return {
+    serialize_str(key): serialize_str(value) for key, value in data.items()
   }
 
 class ErrorEnum(Enum):
@@ -4058,6 +4146,14 @@ def parse_environment_variables_list(data: object) -> EnvironmentVariablesList:
 def serialize_environment_variables_list(data: EnvironmentVariablesList) -> List[object]:
   return [serialize_environment_variable(item) for item in data]
 
+EquipmentConfigList = List[EquipmentConfig]
+
+def parse_equipment_config_list(data: object) -> EquipmentConfigList:
+  return [parse_equipment_config(item) for item in data]
+
+def serialize_equipment_config_list(data: EquipmentConfigList) -> List[object]:
+  return [serialize_equipment_config(item) for item in data]
+
 @dataclass
 class StartRecordingRequest:
   """Request to start recording movement and camera data"""
@@ -4077,7 +4173,7 @@ class StartRecordingRequest:
     if value is None:
       return [True, ""]
 
-    if not isinstance(value, EquipmentKeyAssignments):
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
       return [False, "equipmentKeyAssignments must be of type EquipmentKeyAssignments for StartRecordingRequest, got " + type(value).__name__]
 
     return [True, ""]
@@ -6668,6 +6764,37 @@ def serialize_routine(data: Routine) -> object:
     "environment_variables": None if data.environment_variables is None else serialize_environment_variables_list(data.environment_variables),
   }
 
+@dataclass
+class GetEquipmentConfigResponse:
+  """Response to get the currently-configured equipment
+"""
+  equipment: Union[EquipmentConfigList, None] = None
+
+  def validate_equipment(self, value: EquipmentConfigList) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, list) and all(isinstance(x, EquipmentConfig) for x in value)):
+      return [False, "equipment must be of type EquipmentConfigList for GetEquipmentConfigResponse, got " + type(value).__name__]
+
+    return [True, ""]
+
+  def __post_init__(self):
+    # Type check incoming model - raise error if invalid (required or wrong type)
+    is_valid, error_str = self.validate_equipment(self.equipment)
+    if not is_valid:
+      raise TypeError(error_str)
+
+def parse_get_equipment_config_response(data: object):
+  return GetEquipmentConfigResponse(
+    equipment=parse_equipment_config_list(data["equipment"]) if "equipment" in data and data.get("equipment") is not None else None,
+  )
+
+def serialize_get_equipment_config_response(data: GetEquipmentConfigResponse) -> object:
+  return {
+    "equipment": None if data.equipment is None else serialize_equipment_config_list(data.equipment),
+  }
+
 @dataclass
 class CalibrationData:
   """The result of a calibration"""
@@ -8059,6 +8186,7 @@ class RecorderConfig:
   bots: Union[RecorderBotDetailsList, None] = None
   offset: Union[OffsetConfig, None] = None
   sensors: Union[SensorConfigList, None] = None
+  equipmentKeyAssignments: Union[EquipmentKeyAssignments, None] = None
 
   def validate_isSecondary(self, value: bool) -> Tuple[bool, str]:
     if value is None:
@@ -8114,6 +8242,15 @@ class RecorderConfig:
 
     return [True, ""]
 
+  def validate_equipmentKeyAssignments(self, value: EquipmentKeyAssignments) -> Tuple[bool, str]:
+    if value is None:
+      return [True, ""]
+
+    if not (isinstance(value, dict) and all((isinstance(k, str) and isinstance(val, str)) for k, val in value.items())):
+      return [False, "equipmentKeyAssignments must be of type EquipmentKeyAssignments for RecorderConfig, got " + type(value).__name__]
+
+    return [True, ""]
+
   def __post_init__(self):
     # Type check incoming model - raise error if invalid (required or wrong type)
     is_valid, error_str = self.validate_isSecondary(self.isSecondary)
@@ -8134,6 +8271,9 @@ class RecorderConfig:
     is_valid, error_str = self.validate_sensors(self.sensors)
     if not is_valid:
       raise TypeError(error_str)
+    is_valid, error_str = self.validate_equipmentKeyAssignments(self.equipmentKeyAssignments)
+    if not is_valid:
+      raise TypeError(error_str)
 
 def parse_recorder_config(data: object):
   return RecorderConfig(
@@ -8143,6 +8283,7 @@ def parse_recorder_config(data: object):
     bots=parse_recorder_bot_details_list(data["bots"]) if "bots" in data and data.get("bots") is not None else None,
     offset=parse_offset_config(data["offset"]) if "offset" in data and data.get("offset") is not None else None,
     sensors=parse_sensor_config_list(data["sensors"]) if "sensors" in data and data.get("sensors") is not None else None,
+    equipmentKeyAssignments=parse_equipment_key_assignments(data["equipmentKeyAssignments"]) if "equipmentKeyAssignments" in data and data.get("equipmentKeyAssignments") is not None else None,
   )
 
 def serialize_recorder_config(data: RecorderConfig) -> object:
@@ -8153,6 +8294,7 @@ def serialize_recorder_config(data: RecorderConfig) -> object:
     "bots": None if data.bots is None else serialize_recorder_bot_details_list(data.bots),
     "offset": None if data.offset is None else serialize_offset_config(data.offset),
     "sensors": None if data.sensors is None else serialize_sensor_config_list(data.sensors),
+    "equipmentKeyAssignments": None if data.equipmentKeyAssignments is None else serialize_equipment_key_assignments(data.equipmentKeyAssignments),
   }
 
 @dataclass

{standardbots-2.0.0.dev1751305397.dist-info → standardbots-2.0.1.dist-info}/METADATA

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

standardbots-2.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+standardbots/__init__.py,sha256=PT6Z2HPama2fb6SaNhF3J1skpYABQWGgDzKEtQY6BDM,29
+standardbots/auto_generated/__init__.py,sha256=PZtDUzYcjIO6R-gE-0NzY0vFXk1Je1tJ3je0ivV5o-k,98
+standardbots/auto_generated/apis.py,sha256=PImtR3DhXTi2SAMyaXavFwKIPL_UDU8t7f50E9m-GLw,135953
+standardbots/auto_generated/models.py,sha256=5MnjT25IiCWU1D-mUBC1yKvU2kFB9iv0ymdmP7Q28vc,375459
+tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/fixtures/client_fixt.py,sha256=LfeKYuYfHui-7YEFBlgtV33QN-MEI7DhAkJ6BUoZP6s,633
+tests/fixtures/robot_fixt.py,sha256=6-0SgAjhEOUeydfRRu4dRVX-no1yYQxGKesAtvoPppc,1716
+tests/fixtures/routines_fixt.py,sha256=XdcWUM0dl2SWJhtLd8-xYqI4nh4ge23SqJWquCIrQe0,2124
+standardbots-2.0.1.dist-info/METADATA,sha256=9IaNdXRYQ6NxbLwIPtzJOjtQOrU1w9b2gVWtkJZ45ns,544
+standardbots-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+standardbots-2.0.1.dist-info/top_level.txt,sha256=eHgNxowGe-eEE7gOyeuwXN3bHLClu-TQ1VnsOOzzTkw,19
+standardbots-2.0.1.dist-info/RECORD,,

standardbots-2.0.0.dev1751305397.dist-info/RECORD

@@ -1,12 +0,0 @@
-standardbots/__init__.py,sha256=PT6Z2HPama2fb6SaNhF3J1skpYABQWGgDzKEtQY6BDM,29
-standardbots/auto_generated/__init__.py,sha256=PZtDUzYcjIO6R-gE-0NzY0vFXk1Je1tJ3je0ivV5o-k,98
-standardbots/auto_generated/apis.py,sha256=trnBawZofsn73BlW5xoc9a2Xk6Jv8ZH6hrFJ_Tj05JU,134395
-standardbots/auto_generated/models.py,sha256=0NV8bRT41FDU37JmtNCgw5grJj7MP0qPVsqSwJXRm5E,369635
-tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/fixtures/client_fixt.py,sha256=LfeKYuYfHui-7YEFBlgtV33QN-MEI7DhAkJ6BUoZP6s,633
-tests/fixtures/robot_fixt.py,sha256=6-0SgAjhEOUeydfRRu4dRVX-no1yYQxGKesAtvoPppc,1716
-tests/fixtures/routines_fixt.py,sha256=XdcWUM0dl2SWJhtLd8-xYqI4nh4ge23SqJWquCIrQe0,2124
-standardbots-2.0.0.dev1751305397.dist-info/METADATA,sha256=mAYzGh3kBuxMe5N6KJdifSrW5VoDcAdA01atzqGapV4,558
-standardbots-2.0.0.dev1751305397.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-standardbots-2.0.0.dev1751305397.dist-info/top_level.txt,sha256=eHgNxowGe-eEE7gOyeuwXN3bHLClu-TQ1VnsOOzzTkw,19
-standardbots-2.0.0.dev1751305397.dist-info/RECORD,,