thestage 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

thestage/services/clients/thestage_api/api_client.py

@@ -4,6 +4,8 @@ import httpx
 
 from thestage.helpers.error_handler import error_handler
 from thestage.services.clients.thestage_api.core.api_client_core import TheStageApiClientCore
+from thestage.services.clients.thestage_api.dtos.base_controller.connect_resolve_response import \
+    ConnectResolveOptionsResponse
 from thestage.services.clients.thestage_api.dtos.docker_container_controller.docker_container_list_request import \
     DockerContainerListRequest
 from thestage.services.clients.thestage_api.dtos.docker_container_controller.docker_container_list_response import \
@@ -21,10 +23,10 @@ from thestage.services.clients.thestage_api.dtos.inference_controller.get_infere
     GetInferenceSimulatorRequest
 from thestage.services.clients.thestage_api.dtos.inference_controller.get_inference_simulator_response import \
     GetInferenceSimulatorResponse
-from thestage.services.clients.thestage_api.dtos.inference_controller.inference_simulator_list_for_project_request import \
-    InferenceSimulatorListForProjectRequest
-from thestage.services.clients.thestage_api.dtos.inference_controller.inference_simulator_list_for_project_response import \
-    InferenceSimulatorListForProjectResponse
+from thestage.services.clients.thestage_api.dtos.inference_controller.inference_simulator_list_request import \
+    InferenceSimulatorListRequest
+from thestage.services.clients.thestage_api.dtos.inference_controller.inference_simulator_list_response import \
+    InferenceSimulatorListResponse
 from thestage.services.clients.thestage_api.dtos.inference_controller.inference_simulator_model_list_for_project_request import \
     InferenceSimulatorModelListForProjectRequest
 from thestage.services.clients.thestage_api.dtos.inference_controller.inference_simulator_model_list_for_project_response import \
@@ -104,15 +106,15 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_task(
             self,
-            task_id: int,
+            task_public_id: str,
     ) -> Optional[TaskViewResponse]:
         data = {
-            "taskId": task_id,
+            "taskPublicId": task_public_id,
         }
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/task/view',
+            url='/user-api/v2/task/view',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -122,14 +124,16 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_task_list_for_project(
             self,
-            project_slug: str,
+            project_public_id: Optional[str],
+            project_slug: Optional[str],
             page: int = 1,
             limit: int = 10,
     ) -> Optional[PaginatedEntityList[TaskDto]]:
         request = TaskListForProjectRequest(
+            projectPublicId=project_public_id,
             projectSlug=project_slug,
             entityFilterRequest=EntityFilterRequest(
-                orderByField="id",
+                orderByField="createdAt",
                 orderByDirection=OrderDirectionType.DESC,
                 page=page,
                 limit=limit,
@@ -138,7 +142,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/task/list-for-project',
+            url='/user-api/v2/task/list',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -146,18 +150,20 @@ class TheStageApiClient(TheStageApiClientCore):
         result = TaskListForProjectResponse.model_validate(response) if response else None
         return result.tasks if result and result.is_success else None
 
-    def get_inference_simulator_list_for_project(
+    def get_inference_simulator_list(
             self,
-            project_slug: str,
+            project_public_id: Optional[str],
+            project_slug: Optional[str],
             statuses: List[str] = [],
             page: int = 1,
             limit: int = 10,
     ) -> Optional[PaginatedEntityList[InferenceSimulatorDto]]:
-        request = InferenceSimulatorListForProjectRequest(
+        request = InferenceSimulatorListRequest(
+            projectPublicId=project_public_id,
             projectSlug=project_slug,
             statuses=statuses,
             entityFilterRequest=EntityFilterRequest(
-                orderByField="id",
+                orderByField="createdAt",
                 orderByDirection=OrderDirectionType.DESC,
                 page=page,
                 limit=limit,
@@ -166,25 +172,27 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/project/inference-simulator/list',
+            url='/user-api/v2/inference-simulator/list',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
-        result = InferenceSimulatorListForProjectResponse.model_validate(response) if response else None
+        result = InferenceSimulatorListResponse.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,
-            project_slug: str,
+            project_public_id: Optional[str],
+            project_slug: Optional[str],
             statuses: Optional[List[str]] = None,
             page: int = 1,
             limit: int = 10,
     ) -> Optional[PaginatedEntityList[InferenceSimulatorModelDto]]:
         request = InferenceSimulatorModelListForProjectRequest(
+            projectPublicId=project_public_id,
             projectSlug=project_slug,
             statuses=statuses,
             entityFilterRequest=EntityFilterRequest(
-                orderByField="id",
+                orderByField="createdAt",
                 orderByDirection=OrderDirectionType.DESC,
                 page=page,
                 limit=limit,
@@ -193,7 +201,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/project/inference-simulator-model/list',
+            url='/user-api/v2/inference-simulator-model/list',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -203,19 +211,17 @@ class TheStageApiClient(TheStageApiClientCore):
     def get_rented_instance_list(
             self,
             statuses: List[str],
-            query: Optional[str] = None,
             page: int = 1,
             limit: int = 10,
     ) -> PaginatedEntityList[InstanceRentedDto]:
         data = {
             #"statuses": [item.value for item in statuses],
             "entityFilterRequest": {
-                "orderByField": "id",
+                "orderByField": "createdAt",
                 "orderByDirection": "DESC",
                 "page": page,
                 "limit": limit
             },
-            "queryString": query
         }
 
         if statuses:
@@ -223,7 +229,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v2/instance-rented/list',
+            url='/user-api/v3/instance-rented/list',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -257,19 +263,20 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_rented_instance(
             self,
+            instance_public_id: Optional[str] = None,
             instance_slug: Optional[str] = None,
-            instance_id: Optional[int] = None,
     ) -> Optional[InstanceRentedDto]:
-        if not instance_slug and not instance_id:
+        if not instance_slug and not instance_public_id:
             return None
 
         data = {
+            "instanceRentedPublicId": instance_public_id,
             "instanceRentedSlug": instance_slug,
         }
 
         response = self._request(
             method='POST',
-            url='/user-api/v2/instance-rented/view-by-slug',
+            url='/user-api/v3/instance-rented/view',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -278,19 +285,20 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_selfhosted_instance(
             self,
+            instance_public_id: Optional[str] = None,
             instance_slug: Optional[str] = None,
-            instance_id: Optional[int] = None,
     ) -> Optional[SelfHostedInstanceDto]:
-        if not instance_slug and not instance_id:
+        if not instance_slug and not instance_public_id:
             return None
 
         data = {
+            "selfhostedInstancePublicId": instance_public_id,
             "selfhostedInstanceSlug": instance_slug,
         }
 
         response = self._request(
             method='POST',
-            url='/user-api/v2/self-hosted-instance/view-by-slug',
+            url='/user-api/v3/self-hosted-instance/view',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -300,19 +308,16 @@ class TheStageApiClient(TheStageApiClientCore):
     def get_selfhosted_instance_list(
             self,
             statuses: List[str],
-            query: Optional[str] = None,
             page: int = 1,
             limit: int = 10,
     ) -> PaginatedEntityList[SelfHostedInstanceDto]:
         data = {
-            #"statuses": [item.value for item in statuses] if statuses else [],
             "entityFilterRequest": {
-                "orderByField": "id",
+                "orderByField": "createdAt",
                 "orderByDirection": "DESC",
                 "page": page,
                 "limit": limit
-            },
-            "queryString": query
+            }
         }
 
         if statuses:
@@ -320,7 +325,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v2/self-hosted-instance/list',
+            url='/user-api/v3/self-hosted-instance/list',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -342,15 +347,15 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def cancel_task(
             self,
-            task_id: int,
+            task_public_id: str,
     ) -> Optional[TheStageBaseResponse]:
         data = {
-            "taskId": task_id,
+            "taskPublicId": task_public_id,
         }
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/task/cancel-task',
+            url='/user-api/v2/task/cancel',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -360,16 +365,18 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def get_container_list(
             self,
-            project_id: Optional[int] = None,
+            project_public_id: Optional[str] = None,
+            project_slug: Optional[str] = None,
             statuses: List[str] = [],
             page: int = 1,
             limit: int = 10,
     ) -> PaginatedEntityList[DockerContainerDto]:
         request = DockerContainerListRequest(
             statuses=statuses,
-            projectId=project_id,
+            projectPublicId=project_public_id,
+            projectSlug=project_slug,
             entityFilterRequest=EntityFilterRequest(
-                orderByField="id",
+                orderByField="createdAt",
                 orderByDirection=OrderDirectionType.DESC,
                 page=page,
                 limit=limit,
@@ -378,7 +385,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/docker-container/list',
+            url='/user-api/v2/docker-container/list',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token
         )
@@ -390,23 +397,16 @@ class TheStageApiClient(TheStageApiClientCore):
     def get_container(
             self,
             container_slug: Optional[str] = None,
-            container_id: Optional[int] = None,
+            container_public_id: Optional[str] = None,
     ) -> Optional[DockerContainerDto]:
-        if not container_slug and not container_id:
-            return None
-
-        if container_id:
-            data = {
-                "dockerContainerId": container_id,
-            }
-        else:
-            data = {
-                "dockerContainerSlug": container_slug,
-            }
+        data = {
+            "dockerContainerPublicId": container_public_id,
+            "dockerContainerSlug": container_slug,
+        }
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/docker-container/view',
+            url='/user-api/v2/docker-container/view',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -420,7 +420,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/docker-container/action',
+            url='/user-api/v2/docker-container/action',
             data=request_param.model_dump(by_alias=True),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -439,14 +439,15 @@ class TheStageApiClient(TheStageApiClientCore):
         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) -> Optional[ProjectDto]:
+    def get_project(self, slug: Optional[str], public_id: Optional[str]) -> Optional[ProjectDto]:
         data = {
             "projectSlug": slug,
+            "projectPublicId": public_id,
         }
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/project/view-by-slug',
+            url='/user-api/v2/project/view',
             data=data,
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -455,9 +456,9 @@ class TheStageApiClient(TheStageApiClientCore):
         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) -> str:
+    def get_project_deploy_ssh_key(self, public_id: str) -> str:
         request = ProjectGetDeploySshKeyRequest(
-            projectSlug=slug
+            projectPublicId=public_id,
         )
 
         response = self._request(
@@ -472,15 +473,15 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def execute_project_task(
             self,
-            project_slug: str,
+            project_public_id: str,
             run_command: str,
             task_title: str,
-            docker_container_slug: Optional[str] = None,
+            docker_container_public_id: str,
             commit_hash: Optional[str] = None,
     ) -> Optional[ProjectRunTaskResponse]:
         request = ProjectRunTaskRequest(
-            projectSlug=project_slug,
-            dockerContainerSlug=docker_container_slug,
+            projectPublicId=project_public_id,
+            dockerContainerPublicId=docker_container_public_id,
             commitHash=commit_hash,
             runCommand=run_command,
             taskTitle=task_title,
@@ -488,31 +489,31 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/project/execute-task',
+            url='/user-api/v2/task/execute',
             data=request.model_dump(),
             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, 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]:
+    async def poll_logs_httpx(self, docker_container_public_id: Optional[str], last_log_timestamp: str,
+                              last_log_id: str, task_public_id: Optional[str] = None,
+                              inference_simulator_public_id: Optional[str] = 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(
-            inferenceSimulatorId=inference_simulator_id,
-            taskId=task_id,
-            dockerContainerId=docker_container_id,
+            inferenceSimulatorPublicId=inference_simulator_public_id,
+            taskPublicId=task_public_id,
+            dockerContainerPublicId=docker_container_public_id,
             lastLogTimestamp=last_log_timestamp,
             lastLogId=last_log_id
         )
 
         async with httpx.AsyncClient() as client:
             response = await client.post(
-                url=f"{self._get_host()}/user-api/v1/logging/poll",
+                url=f"{self._get_host()}/user-api/v2/logging/poll",
                 headers=request_headers,
                 json=request.model_dump(),
                 timeout=3.5
@@ -528,7 +529,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/ssh-key/add-public-key-to-user',
+            url='/user-api/v2/ssh-key/add-public-key-to-user',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -543,7 +544,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/ssh-key/is-user-has-public-ssh-key',
+            url='/user-api/v2/ssh-key/is-user-has-public-ssh-key',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -551,16 +552,16 @@ class TheStageApiClient(TheStageApiClientCore):
         result = IsUserHasSshPublicKeyResponse.model_validate(response) if response else None
         return result
 
-    def add_public_ssh_key_to_instance_rented(self, instance_rented_id: int,
-                                              ssh_key_pair_id: int) -> AddSshPublicKeyToInstanceResponse:
+    def add_public_ssh_key_to_instance_rented(self, instance_rented_public_id: str,
+                                              ssh_key_pair_public_id: str) -> AddSshPublicKeyToInstanceResponse:
         request = AddSshPublicKeyToInstanceRequest(
-            instanceRentedId=instance_rented_id,
-            sshPublicKeyId=ssh_key_pair_id,
+            instanceRentedPublicId=instance_rented_public_id,
+            sshPublicKeyPublicId=ssh_key_pair_public_id,
         )
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/ssh-key/add-public-ssh-key-to-instance-rented',
+            url='/user-api/v2/ssh-key/add-public-ssh-key-to-instance-rented',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -570,25 +571,29 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def start_project_inference_simulator(
             self,
-            project_slug: str,
+            project_public_id: str,
             commit_hash: Optional[str] = None,
-            rented_instance_unique_id: Optional[str] = None,
-            self_hosted_instance_unique_id: Optional[str] = None,
+            rented_instance_public_id: Optional[str] = None,
+            rented_instance_slug: Optional[str] = None,
+            self_hosted_instance_public_id: Optional[str] = None,
+            self_hosted_instance_slug: Optional[str] = None,
             inference_dir: Optional[str] = None,
             is_skip_installation: Optional[bool] = False,
     ) -> Optional[ProjectStartInferenceSimulatorResponse]:
         request = ProjectStartInferenceSimulatorRequest(
-            projectSlug=project_slug,
+            projectPublicId=project_public_id,
             commitHash=commit_hash,
-            instanceRentedUId=rented_instance_unique_id,
-            selfhostedInstanceUId=self_hosted_instance_unique_id,
+            instanceRentedPublicId=rented_instance_public_id,
+            instanceRentedSlug=rented_instance_slug,
+            selfhostedInstancePublicId=self_hosted_instance_public_id,
+            selfhostedInstanceSlug=self_hosted_instance_slug,
             inferenceDir=inference_dir,
             isSkipInstallation=is_skip_installation,
         )
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/project/inference-simulator/create',
+            url='/user-api/v2/project/inference-simulator/create',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -597,15 +602,17 @@ class TheStageApiClient(TheStageApiClientCore):
 
     def push_project_inference_simulator_model(
             self,
-            slug: str,
+            public_id: Optional[str],
+            slug: Optional[str],
     ) -> Optional[ProjectPushInferenceSimulatorModelResponse]:
         request = ProjectPushInferenceSimulatorModelRequest(
-            slug=slug,
+            inferenceSimulatorPublicId=public_id,
+            inferenceSimulatorSlug=slug,
         )
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/project/inference-simulator/push-model',
+            url='/user-api/v2/inference-simulator/push-model',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -639,15 +646,17 @@ class TheStageApiClient(TheStageApiClientCore):
     @error_handler()
     def get_inference_simulator(
             self,
-            slug: str,
+            public_id: Optional[str] = None,
+            slug: Optional[str] = None,
     ) -> Optional[GetInferenceSimulatorResponse]:
         request = GetInferenceSimulatorRequest(
+            publicId=public_id,
             slug=slug,
         )
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/inference-simulator/get',
+            url='/user-api/v2/inference-simulator/get',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -656,22 +665,28 @@ class TheStageApiClient(TheStageApiClientCore):
     @error_handler()
     def deploy_inference_model_to_instance(
             self,
-            unique_id: str,
-            unique_id_with_timestamp: str,
-            rented_instance_unique_id: Optional[str] = None,
-            self_hosted_instance_unique_id: Optional[str] = None,
+            model_public_id: str,
+            model_slug: str,
+            new_inference_simulator_slug: str,
+            rented_instance_public_id: Optional[str] = None,
+            rented_instance_slug: Optional[str] = None,
+            self_hosted_instance_public_id: Optional[str] = None,
+            self_hosted_instance_slug: Optional[str] = None,
 
     ) -> Optional[DeployInferenceModelToInstanceResponse]:
         request = DeployInferenceModelToInstanceRequest(
-            inferenceSimulatorSlug=unique_id_with_timestamp,
-            modelSlug=unique_id,
-            instanceRentedSlug=rented_instance_unique_id,
-            selfhostedInstanceSlug=self_hosted_instance_unique_id
+            inferenceSimulatorSlug=new_inference_simulator_slug,
+            modelPublicId=model_public_id,
+            modelSlug=model_slug,
+            instancePublicId=rented_instance_public_id,
+            instanceRentedSlug=rented_instance_slug,
+            selfhostedInstancePublicId=self_hosted_instance_public_id,
+            selfhostedInstanceSlug=self_hosted_instance_slug
         )
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/inference-simulator-model/deploy/instance',
+            url='/user-api/v2/inference-simulator-model/deploy/instance',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
@@ -680,11 +695,13 @@ class TheStageApiClient(TheStageApiClientCore):
     @error_handler()
     def deploy_inference_model_to_sagemaker(
             self,
-            unique_id: str,
+            model_public_id: Optional[str],
+            model_slug: Optional[str],
             arn: Optional[str] = None,
     ) -> Optional[DeployInferenceModelToSagemakerResponse]:
         request = DeployInferenceModelToSagemakerRequest(
-            modelSlug=unique_id,
+            modelPublicId=model_public_id,
+            modelSlug=model_slug,
             arn=arn,
         )
 
@@ -696,23 +713,41 @@ class TheStageApiClient(TheStageApiClientCore):
         )
         return DeployInferenceModelToSagemakerResponse.model_validate(response) if response else 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:
+    def query_user_logs(self, limit: int, task_public_id: Optional[str] = None,
+                        inference_simulator_public_id: Optional[str] = None,
+                        container_public_id: Optional[str] = None) -> UserLogsQueryResponse:
         request = UserLogsQueryRequest(
-            inferenceSimulatorId=inference_simulator_id,
-            taskId=task_id,
-            containerId=container_id,
+            inferenceSimulatorPublicId=inference_simulator_public_id,
+            taskPublicId=task_public_id,
+            containerPublicId=container_public_id,
             limit=limit,
             ascendingOrder=False,
         )
 
         response = self._request(
             method='POST',
-            url='/user-api/v1/logging/query-user-logs',
+            url='/user-api/v2/logging/query-user-logs',
             data=request.model_dump(),
             token=self.__config_provider.get_config().main.thestage_auth_token,
         )
 
         result = UserLogsQueryResponse.model_validate(response) if response else None
         return result
+
+
+    def resolve_connect_options(
+            self,
+            entity_identifier: str
+    ) -> Optional[ConnectResolveOptionsResponse]:
+        data = {
+            "entityIdentifier": entity_identifier,
+        }
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v1/connect/resolve-options',
+            data=data,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        return ConnectResolveOptionsResponse.model_validate(response) if response else None

thestage/services/clients/thestage_api/dtos/base_controller/connect_resolve_response.py

@@ -0,0 +1,21 @@
+from typing import Optional, List
+
+from pydantic import Field, BaseModel
+
+from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
+from thestage.services.clients.thestage_api.dtos.frontend_status import FrontendStatusDto
+from thestage.services.task.dto.task_dto import TaskDto
+
+
+class EntityMatchData(BaseModel):
+    publicId: str = Field(alias='publicId')
+    frontendStatus: FrontendStatusDto = Field(alias='frontendStatus')
+    canConnect: bool = Field(alias='canConnect')
+    matchedField: Optional[str] = Field(None, alias='matchedField')
+
+
+class ConnectResolveOptionsResponse(TheStageBaseResponse):
+    taskMatchData: List[EntityMatchData] = Field(None, alias='taskMatchData')
+    dockerContainerMatchData: List[EntityMatchData] = Field(None, alias='dockerContainerMatchData')
+    instanceRentedMatchData: List[EntityMatchData] = Field(None, alias='instanceRentedMatchData')
+    selfhostedInstanceMatchData: List[EntityMatchData] = Field(None, alias='selfhostedInstanceMatchData')

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

@@ -7,5 +7,5 @@ from thestage.services.clients.thestage_api.dtos.enums.container_pending_action
 class DockerContainerActionRequestDto(BaseModel):
     model_config = ConfigDict(use_enum_values=True)
 
-    container_id: Optional[int] = Field(None, alias='dockerContainerId')
+    container_public_id: Optional[str] = Field(None, alias='dockerContainerPublicId')
     action: DockerContainerAction = Field(None, alias='action')