thestage 0.5.46__py3-none-any.whl → 0.5.471__py3-none-any.whl

thestage/services/clients/thestage_api/api_client.py

@@ -1,7 +1,6 @@
 from typing import Optional, List, Tuple, Dict, Iterator
 
 import httpx
-import requests
 
 from thestage.helpers.error_handler import error_handler
 from thestage.services.clients.thestage_api.core.api_client_core import TheStageApiClientCore
@@ -34,11 +33,8 @@ from thestage.services.clients.thestage_api.dtos.inference_simulator_model_respo
     InferenceSimulatorModelStatusMapperResponse
 from thestage.services.clients.thestage_api.dtos.inference_simulator_response import \
     InferenceSimulatorStatusMapperResponse
-from thestage.services.clients.thestage_api.dtos.logging_controller.docker_container_log_stream_request import \
-    DockerContainerLogStreamRequest
 from thestage.services.clients.thestage_api.dtos.logging_controller.log_polling_request import LogPollingRequest
 from thestage.services.clients.thestage_api.dtos.logging_controller.log_polling_response import LogPollingResponse
-from thestage.services.clients.thestage_api.dtos.logging_controller.task_log_stream_request import TaskLogStreamRequest
 from thestage.services.clients.thestage_api.dtos.logging_controller.user_logs_query_request import UserLogsQueryRequest
 from thestage.services.clients.thestage_api.dtos.logging_controller.user_logs_query_response import \
     UserLogsQueryResponse
@@ -89,19 +85,25 @@ from thestage.services.clients.thestage_api.dtos.instance_rented_response import
     InstanceRentedDto, InstanceRentedItemResponse, InstanceRentedBusinessStatusMapperResponse
 
 from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
-from thestage.services.clients.thestage_api.dtos.user_controller.user_profile import UserProfileResponse
+from thestage.services.config_provider.config_provider import ConfigProvider
 from thestage.services.project.dto.inference_simulator_dto import InferenceSimulatorDto
 from thestage.services.project.dto.inference_simulator_model_dto import InferenceSimulatorModelDto
 from thestage.services.task.dto.task_dto import TaskDto
 
 
 class TheStageApiClient(TheStageApiClientCore):
-    def __init__(self, api_url: str, timeout: int = 90):
-        super().__init__(timeout=timeout, url=api_url)
+    __config_provider: ConfigProvider = None
+
+    def __init__(
+            self,
+            config_provider: ConfigProvider,
+    ):
+        # TODO this is super bullshit, remove all abstract classes
+        super().__init__(url=config_provider.get_config().main.thestage_api_url)
+        self.__config_provider = config_provider
 
     def get_task(
             self,
-            token: str,
             task_id: int,
     ) -> Optional[TaskViewResponse]:
         data = {
@@ -112,7 +114,7 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/task/view',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = TaskViewResponse.model_validate(response) if response else None
@@ -120,7 +122,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_task_list_for_project(
             self,
-            token: str,
             project_slug: str,
             page: int = 1,
             limit: int = 10,
@@ -139,7 +140,7 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/task/list-for-project',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = TaskListForProjectResponse.model_validate(response) if response else None
@@ -147,7 +148,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_inference_simulator_list_for_project(
             self,
-            token: str,
             project_slug: str,
             statuses: List[str] = [],
             page: int = 1,
@@ -168,14 +168,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/project/inference-simulator/list',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
         result = InferenceSimulatorListForProjectResponse.model_validate(response) if response else None
         return result.inferenceSimulators if result and result.is_success else None
 
     def get_inference_simulator_model_list_for_project(
             self,
-            token: str,
             project_slug: str,
             statuses: Optional[List[str]] = None,
             page: int = 1,
@@ -196,14 +195,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/project/inference-simulator-model/list',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
         result = InferenceSimulatorModelListForProjectResponse.model_validate(response) if response else None
         return result.inferenceSimulatorModels if result and result.is_success else None
 
     def get_rented_instance_list(
             self,
-            token: str,
             statuses: List[str],
             query: Optional[str] = None,
             page: int = 1,
@@ -227,30 +225,30 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v2/instance-rented/list',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = InstanceRentedListResponse.model_validate(response) if response else None
         return result.paginated_list if result and result.paginated_list else ([], None)
 
-    def get_rented_business_status_map(self, token: str, ) -> Optional[Dict[str, str]]:
+    def get_rented_business_status_map(self) -> Optional[Dict[str, str]]:
         response = self._request(
             method='POST',
             url='/user-api/v2/instance-rented/business-status-localized-map',
             data=None,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         data = InstanceRentedBusinessStatusMapperResponse.model_validate(response) if response else None
 
         return data.instance_rented_business_status_map if data else None
 
-    def get_task_localized_status_map(self, token: str, ) -> Optional[Dict[str, str]]:
+    def get_task_localized_status_map(self) -> Optional[Dict[str, str]]:
         response = self._request(
             method='POST',
             url='/user-api/v1/task/status-localized-mapping',
             data=None,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         data = TaskStatusLocalizedMapResponse.model_validate(response) if response else None
@@ -259,7 +257,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_rented_instance(
             self,
-            token: str,
             instance_slug: Optional[str] = None,
             instance_id: Optional[int] = None,
     ) -> Optional[InstanceRentedDto]:
@@ -274,14 +271,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v2/instance-rented/view-by-slug',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         return InstanceRentedItemResponse.model_validate(response).instance_rented if response else None
 
     def get_selfhosted_instance(
             self,
-            token: str,
             instance_slug: Optional[str] = None,
             instance_id: Optional[int] = None,
     ) -> Optional[SelfHostedInstanceDto]:
@@ -296,14 +292,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v2/self-hosted-instance/view-by-slug',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         return SelfHostedRentedItemResponse.model_validate(response).selfhosted_instance if response else None
 
     def get_selfhosted_instance_list(
             self,
-            token: str,
             statuses: List[str],
             query: Optional[str] = None,
             page: int = 1,
@@ -327,18 +322,18 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v2/self-hosted-instance/list',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = SelfHostedInstanceListResponse.model_validate(response) if response else None
         return result.paginated_list if result and result.paginated_list else ([], None)
 
-    def get_selfhosted_business_status_map(self, token: str, ) -> Optional[Dict[str, str]]:
+    def get_selfhosted_business_status_map(self) -> Optional[Dict[str, str]]:
         response = self._request(
             method='POST',
             url='/user-api/v2/self-hosted-instance/business-status-localized-map',
             data=None,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         data = SelfHostedRentedRentedBusinessStatusMapperResponse.model_validate(response) if response else None
@@ -347,7 +342,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def cancel_task(
             self,
-            token: str,
             task_id: int,
     ) -> Optional[TheStageBaseResponse]:
         data = {
@@ -358,7 +352,7 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/task/cancel-task',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = TheStageBaseResponse.model_validate(response) if response else None
@@ -366,7 +360,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_container_list(
             self,
-            token: str,
             project_id: Optional[int] = None,
             statuses: List[str] = [],
             page: int = 1,
@@ -387,7 +380,7 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/docker-container/list',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token
         )
 
         result = DockerContainerListResponse.model_validate(response) if response else None
@@ -396,7 +389,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_container(
             self,
-            token: str,
             container_slug: Optional[str] = None,
             container_id: Optional[int] = None,
     ) -> Optional[DockerContainerDto]:
@@ -416,14 +408,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/docker-container/view',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         return DockerContainerViewResponse.model_validate(response).docker_container if response else None
 
     def container_action(
             self,
-            token: str,
             request_param: DockerContainerActionRequestDto,
     ) -> TheStageBaseResponse:
 
@@ -431,24 +422,24 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/docker-container/action',
             data=request_param.model_dump(by_alias=True),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = TheStageBaseResponse.model_validate(response) if response else None
         return result
 
-    def get_container_business_status_map(self, token: str, ) -> Optional[Dict[str, str]]:
+    def get_container_business_status_map(self) -> Optional[Dict[str, str]]:
         response = self._request(
             method='POST',
             url='/user-api/v1/docker-container/status-localized-mapping',
             data=None,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         data = ContainerBusinessStatusMapperResponse.model_validate(response) if response else None
         return data.docker_container_status_map if data else None
 
-    def get_project_by_slug(self, slug: str, token: str) -> Optional[ProjectDto]:
+    def get_project_by_slug(self, slug: str) -> Optional[ProjectDto]:
         data = {
             "projectSlug": slug,
         }
@@ -457,14 +448,14 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/project/view-by-slug',
             data=data,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = ProjectViewResponse.model_validate(response) if response else None
         project = ProjectDto.model_validate(result.project) if result else None
         return project if result and result.is_success else None
 
-    def get_project_deploy_ssh_key(self, slug: str, token: str) -> str:
+    def get_project_deploy_ssh_key(self, slug: str) -> str:
         request = ProjectGetDeploySshKeyRequest(
             projectSlug=slug
         )
@@ -473,7 +464,7 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/project/get-deploy-ssh-key',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = ProjectGetDeploySshKeyResponse.model_validate(response) if response else None
@@ -481,7 +472,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def execute_project_task(
             self,
-            token: str,
             project_slug: str,
             run_command: str,
             task_title: str,
@@ -500,15 +490,16 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/project/execute-task',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         return ProjectRunTaskResponse.model_validate(response) if response else None
 
-    async def poll_logs_httpx(self, token: str, docker_container_id: Optional[int], last_log_timestamp: str,
+    async def poll_logs_httpx(self, docker_container_id: Optional[int], last_log_timestamp: str,
                               last_log_id: str, task_id: Optional[int] = None,
                               inference_simulator_id: Optional[int] = None) -> Optional[LogPollingResponse]:
         request_headers = {'Content-Type': 'application/json'}
+        token = self.__config_provider.get_config().main.thestage_auth_token
         if token: request_headers['Authorization'] = f"Bearer {token}"
 
         request = LogPollingRequest(
@@ -529,7 +520,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
             return LogPollingResponse.model_validate(response.json()) if response else None
 
-    def add_public_ssh_key_to_user(self, token: str, public_key: str, note: str) -> AddSshKeyToUserResponse:
+    def add_public_ssh_key_to_user(self, public_key: str, note: str) -> AddSshKeyToUserResponse:
         request = AddSshKeyToUserRequest(
             sshKey=public_key,
             note=note
@@ -539,13 +530,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/ssh-key/add-public-key-to-user',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = AddSshKeyToUserResponse.model_validate(response) if response else None
         return result
 
-    def is_user_has_ssh_public_key(self, token: str, public_key: str) -> IsUserHasSshPublicKeyResponse:
+    def is_user_has_ssh_public_key(self, public_key: str) -> IsUserHasSshPublicKeyResponse:
         request = IsUserHasSshPublicKeyRequest(
             sshKey=public_key,
         )
@@ -554,13 +545,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/ssh-key/is-user-has-public-ssh-key',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = IsUserHasSshPublicKeyResponse.model_validate(response) if response else None
         return result
 
-    def add_public_ssh_key_to_instance_rented(self, token: str, instance_rented_id: int,
+    def add_public_ssh_key_to_instance_rented(self, instance_rented_id: int,
                                               ssh_key_pair_id: int) -> AddSshPublicKeyToInstanceResponse:
         request = AddSshPublicKeyToInstanceRequest(
             instanceRentedId=instance_rented_id,
@@ -571,7 +562,7 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/ssh-key/add-public-ssh-key-to-instance-rented',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = AddSshPublicKeyToInstanceResponse.model_validate(response) if response else None
@@ -579,7 +570,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def start_project_inference_simulator(
             self,
-            token: str,
             project_slug: str,
             slug: str,
             commit_hash: Optional[str] = None,
@@ -602,14 +592,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/project/inference-simulator/create',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         return ProjectStartInferenceSimulatorResponse.model_validate(response) if response else None
 
     def push_project_inference_simulator_model(
             self,
-            token: str,
             slug: str,
     ) -> Optional[ProjectPushInferenceSimulatorModelResponse]:
         request = ProjectPushInferenceSimulatorModelRequest(
@@ -620,29 +609,29 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/project/inference-simulator/push-model',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         return ProjectPushInferenceSimulatorModelResponse.model_validate(response) if response else None
 
-    def get_inference_simulator_business_status_map(self, token: str, ) -> Optional[Dict[str, str]]:
+    def get_inference_simulator_business_status_map(self) -> Optional[Dict[str, str]]:
         response = self._request(
             method='POST',
             url='/user-api/v1/inference-simulator/status-localized-mapping',
             data=None,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         data = InferenceSimulatorStatusMapperResponse.model_validate(response) if response else None
 
         return data.inference_simulator_status_map if data else None
 
-    def get_inference_simulator_model_business_status_map(self, token: str, ) -> Optional[Dict[str, str]]:
+    def get_inference_simulator_model_business_status_map(self) -> Optional[Dict[str, str]]:
         response = self._request(
             method='POST',
             url='/user-api/v1/inference-simulator-model/status-localized-mapping',
             data=None,
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         data = InferenceSimulatorModelStatusMapperResponse.model_validate(response) if response else None
@@ -652,7 +641,6 @@ class TheStageApiClient(TheStageApiClientCore):
     @error_handler()
     def get_inference_simulator(
             self,
-            token: str,
             slug: str,
     ) -> Optional[GetInferenceSimulatorResponse]:
         request = GetInferenceSimulatorRequest(
@@ -663,14 +651,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/inference-simulator/get',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
         return GetInferenceSimulatorResponse.model_validate(response) if response else None
 
     @error_handler()
     def deploy_inference_model_to_instance(
             self,
-            token: str,
             unique_id: str,
             unique_id_with_timestamp: str,
             rented_instance_unique_id: Optional[str] = None,
@@ -688,14 +675,13 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/inference-simulator-model/deploy/instance',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
         return DeployInferenceModelToInstanceResponse.model_validate(response) if response else None
 
     @error_handler()
     def deploy_inference_model_to_sagemaker(
             self,
-            token: str,
             unique_id: str,
             arn: Optional[str] = None,
     ) -> Optional[DeployInferenceModelToSagemakerResponse]:
@@ -708,11 +694,11 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/inference-simulator-model/grant-user-arn-access',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
         return DeployInferenceModelToSagemakerResponse.model_validate(response) if response else None
 
-    def query_user_logs(self, token: str, limit: int, task_id: Optional[int] = None,
+    def query_user_logs(self, limit: int, task_id: Optional[int] = None,
                         inference_simulator_id: Optional[int] = None,
                         container_id: Optional[int] = None) -> UserLogsQueryResponse:
         request = UserLogsQueryRequest(
@@ -727,7 +713,7 @@ class TheStageApiClient(TheStageApiClientCore):
             method='POST',
             url='/user-api/v1/logging/query-user-logs',
             data=request.model_dump(),
-            token=token,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = UserLogsQueryResponse.model_validate(response) if response else None

thestage/services/clients/thestage_api/core/api_client_core.py

@@ -1,16 +1,21 @@
-from typing import Optional, List, Tuple
+import json
+from typing import Optional
 
-from thestage.services.clients.thestage_api.core.api_client_abstract import TheStageApiClientAbstract
-from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
+import requests
+
+from thestage.config import THESTAGE_API_URL
+from thestage.exceptions.auth_exception import AuthException
 from thestage import __version__
+from thestage.services.clients.thestage_api.core.http_client_exception import HttpClientException
+from thestage.services.clients.thestage_api.dtos.validate_token_response import ValidateTokenResponse
 
 
-class TheStageApiClientCore(TheStageApiClientAbstract):
+class TheStageApiClientCore:
+    def __init__(self, url: Optional[str] = None):
+        self.__api_url = url
 
-    def __init__(self, timeout: int = 90, url: Optional[str] = None):
-        super(TheStageApiClientCore, self).__init__(timeout=timeout, url=url)
 
-    def validate_token(self, token: str) -> bool:
+    def validate_token(self, token: str) -> ValidateTokenResponse:
         data = {
             "userApiToken": token,
             "cliVersion": __version__,
@@ -21,5 +26,83 @@ class TheStageApiClientCore(TheStageApiClientAbstract):
             url='/user-api/v1/validate-token',
             data=data,
         )
-        result = TheStageBaseResponse.model_validate(response) if response else None
-        return result.is_success if result else False
+        result = ValidateTokenResponse.model_validate(response) if response else None
+        return result
+
+
+    def _get_host(self, ) -> str:
+        return self.__api_url or THESTAGE_API_URL
+
+    def _request(
+            self,
+            method: str,
+            url: str,
+            data: dict = None,
+            query_params: dict = None,
+            headers: Optional[dict] = None,
+            token: Optional[str] = None,
+    ):
+        if not data:
+            data = {}
+
+        host = self._get_host()
+        url = f'{host}{url}'
+
+        request_headers = {
+            'Content-Type': 'application/json',
+        }
+
+        if token:
+            request_headers['Authorization'] = f"Bearer {token}"
+
+        if headers:
+            request_headers.update(headers)
+        response = requests.request(
+            method=method,
+            url=url,
+            json=data,
+            params=query_params,
+            headers=request_headers,
+            timeout=90,
+
+        )
+        return self._parse_api_response(response)
+
+
+    @staticmethod
+    def _parse_api_response(raw_response):
+        content_type = raw_response.headers.get('content-type')
+        message_error = None
+        if content_type == 'application/json':
+            try:
+                result = raw_response.json()
+                message_error = result.get('message', None)
+            except json.JSONDecodeError:
+                raise HttpClientException(
+                    message=f"Failed to parse server response",
+                    status_code=raw_response.status_code,
+                )
+        else:
+            result = raw_response.content.text()
+
+        if raw_response.status_code == 401:
+            raise AuthException(
+                message=f"Unauthorized",
+            )
+        elif raw_response.status_code == 403:
+            raise HttpClientException(
+                message=f"{message_error if message_error else 'Forbidden'} ({raw_response.status_code})",
+                status_code=raw_response.status_code,
+            )
+        elif raw_response.status_code >= 400:
+            raise HttpClientException(
+                message=f"{message_error if message_error else 'Request error'} ({raw_response.status_code})",
+                status_code=raw_response.status_code,
+            )
+        elif raw_response.status_code < 200 or raw_response.status_code > 300:
+            raise HttpClientException(
+                message=f"{message_error if message_error else 'Request error'} ({raw_response.status_code})",
+                status_code=raw_response.status_code,
+            )
+
+        return result

thestage/services/clients/thestage_api/dtos/container_response.py

@@ -64,4 +64,4 @@ class DockerContainerViewResponse(TheStageBaseResponse):
 class ContainerBusinessStatusMapperResponse(TheStageBasePaginatedResponse):
     model_config = ConfigDict(use_enum_values=True)
 
-    docker_container_status_map: Dict[str, str] = Field(default=dict, alias='dockerContainerStatusMap')
+    docker_container_status_map: Dict[str, str] = Field(default={}, alias='dockerContainerStatusMap')

thestage/services/clients/thestage_api/dtos/inference_simulator_model_response.py

@@ -8,4 +8,4 @@ from thestage.services.clients.thestage_api.dtos.base_response import TheStageBa
 class InferenceSimulatorModelStatusMapperResponse(TheStageBasePaginatedResponse):
     model_config = ConfigDict(use_enum_values=True)
 
-    inference_simulator_model_status_map: Dict[str, str] = Field(default=dict, alias='inferenceSimulatorModelStatusMap')
+    inference_simulator_model_status_map: Dict[str, str] = Field(default={}, alias='inferenceSimulatorModelStatusMap')

thestage/services/clients/thestage_api/dtos/inference_simulator_response.py

@@ -8,4 +8,4 @@ from thestage.services.clients.thestage_api.dtos.base_response import TheStageBa
 class InferenceSimulatorStatusMapperResponse(TheStageBasePaginatedResponse):
     model_config = ConfigDict(use_enum_values=True)
 
-    inference_simulator_status_map: Dict[str, str] = Field(default=dict, alias='inferenceSimulatorStatusMap')
+    inference_simulator_status_map: Dict[str, str] = Field(default={}, alias='inferenceSimulatorStatusMap')

thestage/services/clients/thestage_api/dtos/instance_rented_response.py

@@ -68,4 +68,4 @@ class InstanceRentedItemResponse(TheStageBasePaginatedResponse):
 class InstanceRentedBusinessStatusMapperResponse(TheStageBasePaginatedResponse):
     model_config = ConfigDict(use_enum_values=True)
 
-    instance_rented_business_status_map: Dict[str, str] = Field(default=dict, alias='instanceRentedBusinessStatusMap')
+    instance_rented_business_status_map: Dict[str, str] = Field(default={}, alias='instanceRentedBusinessStatusMap')

thestage/services/clients/thestage_api/dtos/selfhosted_instance_response.py

@@ -53,4 +53,4 @@ class SelfHostedRentedItemResponse(TheStageBasePaginatedResponse):
 class SelfHostedRentedRentedBusinessStatusMapperResponse(TheStageBasePaginatedResponse):
     model_config = ConfigDict(use_enum_values=True)
 
-    selfhosted_instance_business_status_map: Dict[str, str] = Field(default=dict, alias='selfhostedInstanceBusinessStatusMap')
+    selfhosted_instance_business_status_map: Dict[str, str] = Field(default={}, alias='selfhostedInstanceBusinessStatusMap')

thestage/services/clients/thestage_api/dtos/task_controller/task_status_localized_map_response.py

@@ -6,4 +6,4 @@ from thestage.services.clients.thestage_api.dtos.base_response import TheStageBa
 
 
 class TaskStatusLocalizedMapResponse(TheStageBaseResponse):
-    taskStatusMap: Dict[str, str] = Field(default=dict, alias='taskStatusMap')
+    taskStatusMap: Dict[str, str] = Field(default={}, alias='taskStatusMap')