thestage 0.5.43__py3-none-any.whl → 0.5.45__py3-none-any.whl

thestage/services/clients/thestage_api/api_client.py

@@ -85,12 +85,11 @@ from thestage.services.clients.thestage_api.dtos.task_controller.task_list_for_p
 from thestage.services.clients.thestage_api.dtos.task_controller.task_status_localized_map_response import \
     TaskStatusLocalizedMapResponse
 from thestage.services.clients.thestage_api.dtos.task_controller.task_view_response import TaskViewResponse
-from thestage.services.clients.thestage_api.dtos.user_profile import UserProfileResponse
 from thestage.services.clients.thestage_api.dtos.instance_rented_response import InstanceRentedListResponse, \
     InstanceRentedDto, InstanceRentedItemResponse, InstanceRentedBusinessStatusMapperResponse
 
-from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse, \
-    TheStageBasePaginatedResponse
+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.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
@@ -146,7 +145,6 @@ 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(
             self,
             token: str,
@@ -203,7 +201,6 @@ class TheStageApiClient(TheStageApiClientCore):
         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,
@@ -260,7 +257,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         return data.taskStatusMap if data else None
 
-    def get_rented_item(
+    def get_rented_instance(
             self,
             token: str,
             instance_slug: Optional[str] = None,
@@ -282,7 +279,7 @@ class TheStageApiClient(TheStageApiClientCore):
 
         return InstanceRentedItemResponse.model_validate(response).instance_rented if response else None
 
-    def get_selfhosted_item(
+    def get_selfhosted_instance(
             self,
             token: str,
             instance_slug: Optional[str] = None,
@@ -347,21 +344,8 @@ class TheStageApiClient(TheStageApiClientCore):
         data = SelfHostedRentedRentedBusinessStatusMapperResponse.model_validate(response) if response else None
         return data.selfhosted_instance_business_status_map if data else None
 
-    def get_profile(
-            self,
-            token: str,
-    ) -> Optional[UserProfileResponse]:
 
-        response = self._request(
-            method='GET',
-            url='/frontend-api/user/my-profile',
-            token=token,
-        )
-
-        result = UserProfileResponse.model_validate(response) if response else None
-        return result if result else None
-
-    def stop_task_on_instance(
+    def cancel_task(
             self,
             token: str,
             task_id: int,
@@ -521,8 +505,9 @@ class TheStageApiClient(TheStageApiClientCore):
 
         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, last_log_id: str, task_id: Optional[int] = None, inference_simulator_id: Optional[int] = None) -> Optional[LogPollingResponse]:
+    async def poll_logs_httpx(self, token: str, 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'}
         if token: request_headers['Authorization'] = f"Bearer {token}"
 
@@ -544,7 +529,6 @@ 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:
         request = AddSshKeyToUserRequest(
             sshKey=public_key,
@@ -561,7 +545,6 @@ class TheStageApiClient(TheStageApiClientCore):
         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:
         request = IsUserHasSshPublicKeyRequest(
             sshKey=public_key,
@@ -577,8 +560,8 @@ class TheStageApiClient(TheStageApiClientCore):
         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, ssh_key_pair_id: int) -> AddSshPublicKeyToInstanceResponse:
+    def add_public_ssh_key_to_instance_rented(self, token: str, instance_rented_id: int,
+                                              ssh_key_pair_id: int) -> AddSshPublicKeyToInstanceResponse:
         request = AddSshPublicKeyToInstanceRequest(
             instanceRentedId=instance_rented_id,
             sshPublicKeyId=ssh_key_pair_id,
@@ -594,7 +577,6 @@ class TheStageApiClient(TheStageApiClientCore):
         result = AddSshPublicKeyToInstanceResponse.model_validate(response) if response else None
         return result
 
-
     def start_project_inference_simulator(
             self,
             token: str,
@@ -625,7 +607,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
         return ProjectStartInferenceSimulatorResponse.model_validate(response) if response else None
 
-
     def push_project_inference_simulator_model(
             self,
             token: str,
@@ -644,7 +625,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
         return ProjectPushInferenceSimulatorModelResponse.model_validate(response) if response else None
 
-
     def get_inference_simulator_business_status_map(self, token: str, ) -> Optional[Dict[str, str]]:
         response = self._request(
             method='POST',
@@ -657,7 +637,6 @@ class TheStageApiClient(TheStageApiClientCore):
 
         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]]:
         response = self._request(
             method='POST',
@@ -688,7 +667,6 @@ class TheStageApiClient(TheStageApiClientCore):
         )
         return GetInferenceSimulatorResponse.model_validate(response) if response else None
 
-
     @error_handler()
     def deploy_inference_model_to_instance(
             self,
@@ -702,8 +680,8 @@ class TheStageApiClient(TheStageApiClientCore):
         request = DeployInferenceModelToInstanceRequest(
             inferenceSimulatorSlug=unique_id_with_timestamp,
             modelSlug=unique_id,
-            instanceRentedSlug = rented_instance_unique_id,
-            selfhostedInstanceSlug = self_hosted_instance_unique_id
+            instanceRentedSlug=rented_instance_unique_id,
+            selfhostedInstanceSlug=self_hosted_instance_unique_id
         )
 
         response = self._request(
@@ -714,7 +692,6 @@ class TheStageApiClient(TheStageApiClientCore):
         )
         return DeployInferenceModelToInstanceResponse.model_validate(response) if response else None
 
-
     @error_handler()
     def deploy_inference_model_to_sagemaker(
             self,
@@ -735,8 +712,9 @@ class TheStageApiClient(TheStageApiClientCore):
         )
         return DeployInferenceModelToSagemakerResponse.model_validate(response) if response else None
 
-
-    def query_user_logs(self, token: str, limit: int, task_id: Optional[int] = None, inference_simulator_id: Optional[int] = None, container_id: Optional[int] = None) -> UserLogsQueryResponse:
+    def query_user_logs(self, token: str, limit: int, task_id: Optional[int] = None,
+                        inference_simulator_id: Optional[int] = None,
+                        container_id: Optional[int] = None) -> UserLogsQueryResponse:
         request = UserLogsQueryRequest(
             inferenceSimulatorId=inference_simulator_id,
             taskId=task_id,
@@ -753,4 +731,4 @@ class TheStageApiClient(TheStageApiClientCore):
         )
 
         result = UserLogsQueryResponse.model_validate(response) if response else None
-        return result
+        return result

thestage/services/clients/thestage_api/dtos/{user_profile.py → user_controller/user_profile.py}

@@ -3,7 +3,10 @@ from typing import Optional
 from pydantic import BaseModel, Field
 
 
-class UserProfileResponse(BaseModel):
-    name: Optional[str] = Field(None, alias='name')
+class UserProfile(BaseModel):
     email: Optional[str] = Field(None, alias='email')
-    metamask_wallet: Optional[str] = Field(None, alias='metamaskWallet')
+
+
+
+class UserProfileResponse(BaseModel):
+    userProfile: Optional[UserProfile] = Field(None, alias='userProfile')

thestage/services/config_provider/config_provider.py

@@ -10,7 +10,7 @@ from thestage.exceptions.file_system_exception import FileSystemException
 from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.helpers.ssh_util import parse_private_key
 from thestage.services.connect.dto.remote_server_config import RemoteServerConfig
-from thestage.services.filesystem_service import FileSystemServiceCore
+from thestage.services.filesystem_service import FileSystemService
 from thestage.services.project.dto.project_config import ProjectConfig
 from thestage.config import THESTAGE_CONFIG_DIR, THESTAGE_CONFIG_FILE, THESTAGE_AUTH_TOKEN, THESTAGE_API_URL
 
@@ -20,30 +20,27 @@ class ConfigProvider():
     _local_config_path: Optional[Path] = None
     _global_config_path: Optional[Path] = None
     _global_config_file: Optional[Path] = None
-    _file_system_service = FileSystemServiceCore
+    _file_system_service = FileSystemService
 
 
     def __init__(
             self,
             local_path: Optional[str] = None,
     ):
-        self._file_system_service = FileSystemServiceCore()
+        self._file_system_service = FileSystemService()
         if local_path:
             self._local_path = self._file_system_service.get_path(directory=local_path, auto_create=False)
 
-        config_folder_name = self._file_system_service.get_path(f"{THESTAGE_CONFIG_DIR}", False)
-        self._local_config_path = self._local_path.joinpath(config_folder_name)
+        self._local_config_path = self._local_path.joinpath(THESTAGE_CONFIG_DIR)
 
         home_dir = self._file_system_service.get_home_path()
-        self._global_config_path = home_dir.joinpath(config_folder_name)
+        self._global_config_path = home_dir.joinpath(THESTAGE_CONFIG_DIR)
 
         if self._global_config_path:
             if not self._global_config_path.exists():
                 self._file_system_service.create_if_not_exists_dir(self._global_config_path)
 
-        self._global_config_file = self._global_config_path.joinpath(
-            self._file_system_service.get_path(f"{THESTAGE_CONFIG_FILE}", False)
-        )
+        self._global_config_file = self._global_config_path.joinpath(THESTAGE_CONFIG_FILE)
         if not self._global_config_file.exists():
             self._file_system_service.create_if_not_exists_file(self._global_config_file)
 
@@ -61,7 +58,7 @@ class ConfigProvider():
         if config_from_env:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_env)
 
-        config_from_file = self.__read_config_file(self._global_config_file)
+        config_from_file = self._file_system_service.read_config_file(self._global_config_file)
         if config_from_file:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_file)
 
@@ -112,7 +109,7 @@ class ConfigProvider():
         if not project_data_filepath.exists():
             return None
 
-        config_data = self.__read_config_file(project_data_filepath) if project_data_filepath and project_data_filepath.exists() else {}
+        config_data = self._file_system_service.read_config_file(project_data_filepath) if project_data_filepath and project_data_filepath.exists() else {}
         return ProjectConfig.model_validate(config_data)
 
 
@@ -165,7 +162,7 @@ class ConfigProvider():
         if not config_filepath.is_file():
             return None
 
-        config_data = self.__read_config_file(config_filepath) if config_filepath and config_filepath.exists() else {}
+        config_data = self._file_system_service.read_config_file(config_filepath) if config_filepath and config_filepath.exists() else {}
         return RemoteServerConfig.model_validate(config_data)
 
 
@@ -188,22 +185,6 @@ class ConfigProvider():
             else:
                 values_to_update['main'] = new_values['main']
 
-
-    def __read_config_file(self, path: Path) -> Dict[str, Any]:
-        result = {}
-        try:
-            if path and path.exists():
-                with path.open("r") as file:
-                    try:
-                        if os.stat(path).st_size != 0:
-                            result = json.load(file)
-                    except JSONDecodeError:
-                        pass
-        except OSError:
-            raise FileSystemException(f"Could not open config file: {path}")
-        return result
-
-
     @staticmethod
     def __save_config_file(data: Dict, file_path: Path):
         with open(file_path, 'w') as configfile:
@@ -211,7 +192,7 @@ class ConfigProvider():
 
 
     def save_config(self, config: ConfigEntity):
-        data: Dict[str, Any] = self.__read_config_file(self._global_config_file)
+        data: Dict[str, Any] = self._file_system_service.read_config_file(self._global_config_file)
         data.update(config.model_dump(exclude_none=True, by_alias=True, exclude={'runtime', 'RUNTIME', 'daemon', 'DAEMON'}))
         self.__save_config_file(data=data, file_path=self._global_config_file)
 

thestage/services/connect/connect_service.py

@@ -50,20 +50,25 @@ class ConnectService(AbstractService):
     ):
         config = self._config_provider.get_full_config()
 
-        # TODO make a single separate method that will return all needed info
         try:
-            instance_selfhosted = self.__thestage_api_client.get_selfhosted_item(token=config.main.thestage_auth_token, instance_slug=uid)
+            instance_selfhosted = self.__thestage_api_client.get_selfhosted_instance(token=config.main.thestage_auth_token, instance_slug=uid)
         except HttpClientException as e:
+            if e.get_status_code() == 403:
+                typer.echo("Missing permission to view self-hosted instances")
             instance_selfhosted = None
 
         try:
-            instance_rented = self.__thestage_api_client.get_rented_item(token=config.main.thestage_auth_token, instance_slug=uid)
+            instance_rented = self.__thestage_api_client.get_rented_instance(token=config.main.thestage_auth_token, instance_slug=uid)
         except HttpClientException as e:
+            if e.get_status_code() == 403:
+                typer.echo("Missing permission to view rented instances")
             instance_rented = None
 
         try:
             container = self.__thestage_api_client.get_container(token=config.main.thestage_auth_token, container_slug=uid, )
-        except Exception as e:
+        except HttpClientException as e:
+            if e.get_status_code() == 403:
+                typer.echo("Missing permission to view containers")
             container = None
 
         task: Optional[TaskDto] = None
@@ -71,6 +76,8 @@ class ConnectService(AbstractService):
             try:
                 task_view_response = self.__thestage_api_client.get_task(token=config.main.thestage_auth_token, task_id=int(uid))
             except HttpClientException as e:
+                if e.get_status_code() == 403:
+                    typer.echo("Missing permission to view tasks")
                 task_view_response = None
             if task_view_response and task_view_response.task:
                 task = task_view_response.task
@@ -148,7 +155,7 @@ class ConnectService(AbstractService):
         instance_rented: Optional[InstanceRentedDto] = None
         if instance_slug:
             try:
-                instance_rented = self.__thestage_api_client.get_rented_item(token=config.main.thestage_auth_token, instance_slug=instance_slug)
+                instance_rented = self.__thestage_api_client.get_rented_instance(token=config.main.thestage_auth_token, instance_slug=instance_slug)
             except HttpClientException as e:
                 instance_rented = None
 

thestage/services/container/container_service.py

@@ -10,7 +10,7 @@ from thestage.services.clients.thestage_api.dtos.enums.container_status import D
 from thestage.entities.enums.shell_type import ShellType
 from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
 from thestage.services.container.mapper.container_mapper import ContainerMapper
-from thestage.services.filesystem_service import FileSystemServiceCore
+from thestage.services.filesystem_service import FileSystemService
 from thestage.services.remote_server_service import RemoteServerService
 from thestage.i18n.translation import __
 from thestage.services.abstract_service import AbstractService
@@ -29,7 +29,7 @@ class ContainerService(AbstractService):
             thestage_api_client: TheStageApiClient,
             config_provider: ConfigProvider,
             remote_server_service: RemoteServerService,
-            file_system_service: FileSystemServiceCore,
+            file_system_service: FileSystemService,
     ):
         super(ContainerService, self).__init__(
             config_provider=config_provider

thestage/services/core_files/config_entity.py

@@ -7,11 +7,6 @@ class MainConfigEntity(BaseModel):
     thestage_auth_token: Optional[str] = Field(None, alias='thestage_auth_token')
     thestage_api_url: Optional[str] = Field(None, alias='thestage_api_url')
 
-
-class DaemonConfigEntity(BaseModel):
-    daemon_token: Optional[str] = Field(None, alias='daemon_token')
-    backend_api_url: Optional[str] = Field(None, alias='backend_api_url')
-
 # not saved to file
 class RuntimeConfigEntity(BaseModel):
     working_directory: Optional[str] = Field(None, alias='working_directory')
@@ -19,7 +14,7 @@ class RuntimeConfigEntity(BaseModel):
 
 
 class ConfigEntity(BaseModel):
+    global_config_path: str = Field(None, alias='global_config_path')
+    can_use_inference: bool = Field(None, alias='can_use_inference')
     main: MainConfigEntity = Field(default_factory=MainConfigEntity, alias='main')
     runtime: RuntimeConfigEntity = Field(default_factory=RuntimeConfigEntity, alias="runtime") # TODO merge with main
-    daemon: DaemonConfigEntity = Field(default_factory=DaemonConfigEntity, alias="daemon") # TODO this should not be in core package
-    start_on_daemon: bool = Field(False, alias='start_on_daemon') # TODO this should not be in core package

thestage/services/filesystem_service.py

@@ -1,13 +1,15 @@
+import json
 import os
 import shutil
+from json import JSONDecodeError
 from pathlib import Path
-from typing import Optional, List
+from typing import Optional, List, Dict, Any
 
 from thestage.entities.file_item import FileItemEntity
 from thestage.exceptions.file_system_exception import FileSystemException
 
 
-class FileSystemServiceCore:
+class FileSystemService:
 
     def get_ssh_path(self) -> Optional[Path]:
         home_path = self.get_home_path()
@@ -83,6 +85,7 @@ class FileSystemServiceCore:
                 file.write(new_line)
                 file.write('\n')
 
+    # TODO remove this fucking useless shit
     def check_if_path_exist(self, file: str) -> bool:
         path = self.get_path(file, auto_create=False)
         if path.exists():
@@ -113,3 +116,18 @@ class FileSystemServiceCore:
         real_path = self.get_path(directory=path, auto_create=False)
         if real_path and real_path.exists():
             shutil.rmtree(real_path)
+
+
+    def read_config_file(self, path: Path) -> Dict[str, Any]:
+        result = {}
+        try:
+            if path and path.exists():
+                with path.open("r") as file:
+                    try:
+                        if os.stat(path).st_size != 0:
+                            result = json.load(file)
+                    except JSONDecodeError:
+                        pass
+        except OSError:
+            raise FileSystemException(f"Could not open config file: {path}")
+        return result

thestage/services/instance/instance_service.py

@@ -2,6 +2,9 @@ from pathlib import Path
 from typing import List, Optional, Dict
 
 import typer
+
+from thestage.entities.rented_instance import RentedInstanceEntity
+from thestage.entities.self_hosted_instance import SelfHostedInstanceEntity
 from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.i18n.translation import __
 from thestage.services.clients.thestage_api.dtos.enums.selfhosted_status import SelfhostedBusinessStatus
@@ -13,6 +16,8 @@ from thestage.services.clients.thestage_api.dtos.instance_rented_response import
 from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
 from thestage.services.clients.thestage_api.dtos.selfhosted_instance_response import SelfHostedInstanceDto
 from thestage.services.config_provider.config_provider import ConfigProvider
+from thestage.services.instance.mapper.instance_mapper import InstanceMapper
+from thestage.services.instance.mapper.selfhosted_mapper import SelfHostedMapper
 from thestage.services.remote_server_service import RemoteServerService
 
 
@@ -32,22 +37,22 @@ class InstanceService(AbstractService):
         self.__thestage_api_client = thestage_api_client
         self.__remote_server_service = remote_server_service
 
-    def get_rented_item(
+    def get_rented_instance(
             self,
             config: ConfigEntity,
             instance_slug: str,
     ) -> Optional[InstanceRentedDto]:
-        return self.__thestage_api_client.get_rented_item(
+        return self.__thestage_api_client.get_rented_instance(
             token=config.main.thestage_auth_token,
             instance_slug=instance_slug,
         )
 
-    def get_self_hosted_item(
+    def get_self_hosted_instance(
             self,
             config: ConfigEntity,
             instance_slug: str,
     ) -> Optional[SelfHostedInstanceDto]:
-        return self.__thestage_api_client.get_selfhosted_item(
+        return self.__thestage_api_client.get_selfhosted_instance(
             token=config.main.thestage_auth_token,
             instance_slug=instance_slug,
         )
@@ -121,7 +126,7 @@ class InstanceService(AbstractService):
             config: ConfigEntity,
             input_ssh_key_path: Optional[str]
     ):
-        instance = self.get_rented_item(config=config, instance_slug=instance_rented_slug)
+        instance = self.get_rented_instance(config=config, instance_slug=instance_rented_slug)
 
         if instance:
             self.check_instance_status_to_connect(
@@ -162,7 +167,7 @@ class InstanceService(AbstractService):
             username = 'root'
             typer.echo(__("No remote server username provided, using 'root' as username"))
 
-        instance = self.get_self_hosted_item(config=config, instance_slug=selfhosted_instance_slug)
+        instance = self.get_self_hosted_instance(config=config, instance_slug=selfhosted_instance_slug)
 
         if instance:
             self.check_selfhosted_status_to_connect(
@@ -222,3 +227,92 @@ class InstanceService(AbstractService):
             limit=row,
         )
         return data
+
+
+    @error_handler()
+    def print_self_hosted_instance_list(self, config: ConfigEntity, statuses, row, page):
+        selfhosted_instance_status_map = self.__thestage_api_client.get_selfhosted_business_status_map(config.main.thestage_auth_token)
+
+        if not statuses:
+            statuses = ({key: selfhosted_instance_status_map[key] for key in [
+                SelfhostedBusinessStatus.AWAITING_CONFIGURATION,
+                SelfhostedBusinessStatus.RUNNING,
+                SelfhostedBusinessStatus.TERMINATED,
+            ]}).values()
+
+        if "all" in statuses:
+            statuses = selfhosted_instance_status_map.values()
+
+        for input_status_item in statuses:
+            if input_status_item not in selfhosted_instance_status_map.values():
+                typer.echo(__("'%invalid_status%' is not one of %valid_statuses%", {
+                    'invalid_status': input_status_item,
+                    'valid_statuses': str(list(selfhosted_instance_status_map.values()))
+                }))
+                raise typer.Exit(1)
+
+        typer.echo(__(
+            "Listing self-hosted instances with the following statuses: %statuses%, to view all self-hosted instances, use --status all",
+            placeholders={
+                'statuses': ', '.join([status_item for status_item in statuses])
+            }))
+
+        backend_statuses: List[str] = [key for key, value in selfhosted_instance_status_map.items() if value in statuses]
+
+        self.print(
+            func_get_data=self.get_self_hosted_list,
+            func_special_params={
+                'statuses': backend_statuses,
+            },
+            mapper=SelfHostedMapper(),
+            config=config,
+            headers=list(map(lambda x: x.alias, SelfHostedInstanceEntity.model_fields.values())),
+            row=row,
+            page=page,
+            show_index="never",
+        )
+
+
+    @error_handler()
+    def print_rented_instance_list(self, config: ConfigEntity, statuses, row, page):
+        instance_rented_status_map = self.__thestage_api_client.get_rented_business_status_map(config.main.thestage_auth_token)
+
+        if not statuses:
+            statuses = ({key: instance_rented_status_map[key] for key in [
+                InstanceRentedBusinessStatus.ONLINE,
+                InstanceRentedBusinessStatus.CREATING,
+                InstanceRentedBusinessStatus.TERMINATING,
+                InstanceRentedBusinessStatus.REBOOTING,
+            ]}).values()
+
+        if "all" in statuses:
+            statuses = instance_rented_status_map.values()
+
+        for input_status_item in statuses:
+            if input_status_item not in instance_rented_status_map.values():
+                typer.echo(__("'%invalid_status%' is not one of %valid_statuses%", {
+                    'invalid_status': input_status_item,
+                    'valid_statuses': str(list(instance_rented_status_map.values()))
+                }))
+                raise typer.Exit(1)
+
+        typer.echo(__(
+            "Listing rented server instances with the following statuses: %statuses%, to view all rented server instances, use --status all",
+            placeholders={
+                'statuses': ', '.join([status_item for status_item in statuses])
+            }))
+
+        backend_statuses: List[str] = [key for key, value in instance_rented_status_map.items() if value in statuses]
+
+        self.print(
+            func_get_data=self.get_rented_list,
+            func_special_params={
+                'statuses': backend_statuses,
+            },
+            mapper=InstanceMapper(),
+            config=config,
+            headers=list(map(lambda x: x.alias, RentedInstanceEntity.model_fields.values())),
+            row=row,
+            page=page,
+            show_index="never",
+        )

thestage/services/logging/logging_service.py

@@ -151,7 +151,7 @@ class LoggingService(AbstractService):
             print_logs_task.cancel()
             if not input_task.result():  # result is only expected if ctrl+D triggered EOFError
                 typer.echo(f"\rTask {task_id} will be canceled")
-                self.__thestage_api_client.stop_task_on_instance(
+                self.__thestage_api_client.cancel_task(
                     token=config.main.thestage_auth_token,
                     task_id=task.id,
                 )