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

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()
@@ -114,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,
         )
@@ -100,7 +105,7 @@ class InstanceService(AbstractService):
                 typer.echo(__('Cannot connect to self-hosted instance: it is awaiting configuration'))
                 raise typer.Exit(1)
             elif instance.frontend_status.status_key in [
-                SelfhostedBusinessStatus.TERMINATED.name,
+                SelfhostedBusinessStatus.UNREACHABLE_DAEMON.name,
                 SelfhostedBusinessStatus.DELETED.name,
             ]:
                 typer.echo(__('Cannot connect to self-hosted instance: it may be turned off or unreachable'))
@@ -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.UNREACHABLE_DAEMON,
+            ]}).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/project/project_service.py

@@ -12,7 +12,12 @@ import typer
 from git import Commit
 from tabulate import tabulate
 
+from thestage.entities.project_inference_simulator import ProjectInferenceSimulatorEntity
+from thestage.entities.project_inference_simulator_model import ProjectInferenceSimulatorModelEntity
+from thestage.entities.project_task import ProjectTaskEntity
 from thestage.services.clients.thestage_api.core.http_client_exception import HttpClientException
+from thestage.services.clients.thestage_api.dtos.enums.inference_model_status import InferenceModelStatus
+from thestage.services.clients.thestage_api.dtos.enums.inference_simulator_status import InferenceSimulatorStatus
 from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.color_scheme.color_scheme import ColorScheme
 from thestage.entities.enums.yes_no_response import YesOrNoResponse
@@ -36,9 +41,12 @@ from thestage.services.clients.thestage_api.dtos.project_controller.project_star
     ProjectStartInferenceSimulatorResponse
 from thestage.services.clients.thestage_api.dtos.project_response import ProjectDto
 from thestage.services.clients.thestage_api.dtos.task_controller.task_view_response import TaskViewResponse
-from thestage.services.filesystem_service import FileSystemServiceCore
+from thestage.services.filesystem_service import FileSystemService
 from thestage.services.project.dto.inference_simulator_dto import InferenceSimulatorDto
 from thestage.services.project.dto.inference_simulator_model_dto import InferenceSimulatorModelDto
+from thestage.services.project.mapper.project_inference_simulator_mapper import ProjectInferenceSimulatorMapper
+from thestage.services.project.mapper.project_inference_simulator_model_mapper import \
+    ProjectInferenceSimulatorModelMapper
 from thestage.services.task.dto.task_dto import TaskDto
 from thestage.services.project.dto.project_config import ProjectConfig
 from thestage.services.project.mapper.project_task_mapper import ProjectTaskMapper
@@ -58,7 +66,7 @@ class ProjectService(AbstractService):
             thestage_api_client: TheStageApiClient,
             config_provider: ConfigProvider,
             remote_server_service: RemoteServerService,
-            file_system_service: FileSystemServiceCore,
+            file_system_service: FileSystemService,
             git_local_client: GitLocalClient,
     ):
         super(ProjectService, self).__init__(
@@ -1139,3 +1147,134 @@ class ProjectService(AbstractService):
             deploy_key_path=project_config.deploy_key_path,
             reset_to_origin=True
         )
+
+
+    @error_handler()
+    def print_inference_simulator_list(self, config, project_uid, statuses, row, page):
+        if not project_uid:
+            project_config: ProjectConfig = self.__config_provider.read_project_config()
+            if not project_config:
+                typer.echo(__("Provide the project unique ID or run this command from within an initialized project directory"))
+                raise typer.Exit(1)
+            project_uid = project_config.slug
+
+        inference_simulator_status_map = self.__thestage_api_client.get_inference_simulator_business_status_map(
+            config.main.thestage_auth_token)
+
+        if not statuses:
+            statuses = ({key: inference_simulator_status_map[key] for key in [
+                InferenceSimulatorStatus.SCHEDULED,
+                InferenceSimulatorStatus.CREATING,
+                InferenceSimulatorStatus.RUNNING,
+            ]}).values()
+
+        if "all" in statuses:
+            statuses = inference_simulator_status_map.values()
+
+        for input_status_item in statuses:
+            if input_status_item not in inference_simulator_status_map.values():
+                typer.echo(__("'%invalid_status%' is not one of %valid_statuses%", {
+                    'invalid_status': input_status_item,
+                    'valid_statuses': str(list(inference_simulator_status_map.values()))
+                }))
+                raise typer.Exit(1)
+
+        typer.echo(__(
+            "Listing inference simulators with the following statuses: %statuses%, to view all inference simulators, use --status all",
+            placeholders={
+                'statuses': ', '.join([status_item for status_item in statuses])
+            }))
+
+        backend_statuses: List[str] = [key for key, value in inference_simulator_status_map.items() if value in statuses]
+
+        self.print(
+            func_get_data=self.get_project_inference_simulator_list,
+            func_special_params={
+                'project_slug': project_uid,
+                'statuses': backend_statuses,
+            },
+            mapper=ProjectInferenceSimulatorMapper(),
+            config=config,
+            headers=list(map(lambda x: x.alias, ProjectInferenceSimulatorEntity.model_fields.values())),
+            row=row,
+            page=page,
+            max_col_width=[100, 100, 100, 100, 100, 100, 100, 100],
+            show_index="never",
+        )
+
+
+    @error_handler()
+    def print_inference_simulator_model_list(self, config, project_uid, statuses, row, page):
+        if not project_uid:
+            project_config: ProjectConfig = self.__config_provider.read_project_config()
+            if not project_config:
+                typer.echo(__("Provide the project unique ID or run this command from within an initialized project directory"))
+                raise typer.Exit(1)
+            project_uid = project_config.slug
+
+        inference_simulator_model_status_map = self.__thestage_api_client.get_inference_simulator_model_business_status_map(
+            config.main.thestage_auth_token)
+
+        if not statuses:
+            statuses = ({key: inference_simulator_model_status_map[key] for key in [
+                InferenceModelStatus.SCHEDULED,
+                InferenceModelStatus.PROCESSING,
+                InferenceModelStatus.PUSH_SUCCEED,
+            ]}).values()
+
+        if "all" in statuses:
+            statuses = inference_simulator_model_status_map.values()
+
+        for input_status_item in statuses:
+            if input_status_item not in inference_simulator_model_status_map.values():
+                typer.echo(__("'%invalid_status%' is not one of %valid_statuses%", {
+                    'invalid_status': input_status_item,
+                    'valid_statuses': str(list(inference_simulator_model_status_map.values()))
+                }))
+                raise typer.Exit(1)
+
+        typer.echo(__(
+            "Listing inference simulator models with the following statuses: %statuses%, to view all inference simulator models, use --status all",
+            placeholders={
+                'statuses': ', '.join([status_item for status_item in statuses])
+            }))
+
+        backend_statuses: List[str] = [key for key, value in inference_simulator_model_status_map.items() if value in statuses]
+
+        self.print(
+            func_get_data=self.get_project_inference_simulator_model_list,
+            func_special_params={
+                'project_slug': project_uid,
+                'statuses': backend_statuses,
+            },
+            mapper=ProjectInferenceSimulatorModelMapper(),
+            config=config,
+            headers=list(map(lambda x: x.alias, ProjectInferenceSimulatorModelEntity.model_fields.values())),
+            row=row,
+            page=page,
+            max_col_width=[100, 100, 100, 100, 100, 100, 100, 100],
+            show_index="never",
+        )
+
+
+    def print_task_list(self, config: ConfigEntity, project_uid, row, page):
+        if not project_uid:
+            project_config: ProjectConfig = self.__config_provider.read_project_config()
+            if not project_config:
+                typer.echo(__("Provide the project unique ID or run this command from within an initialized project directory"))
+                raise typer.Exit(1)
+            project_uid = project_config.slug
+
+        self.print(
+            func_get_data=self.get_project_task_list,
+            func_special_params={
+                'project_slug': project_uid,
+            },
+            mapper=ProjectTaskMapper(),
+            config=config,
+            headers=list(map(lambda x: x.alias, ProjectTaskEntity.model_fields.values())),
+            row=row,
+            page=page,
+            max_col_width=[100, 100, 100, 100, 100, 100, 100, 100],
+            show_index="never",
+        )

thestage/services/remote_server_service.py

@@ -21,7 +21,7 @@ from thestage.helpers.ssh_util import parse_private_key
 from thestage.i18n.translation import __
 from thestage.services.clients.thestage_api.dtos.sftp_path_helper import SftpFileItemEntity
 from thestage.services.config_provider.config_provider import ConfigProvider
-from thestage.services.filesystem_service import FileSystemServiceCore
+from thestage.services.filesystem_service import FileSystemService
 
 old_value: int = 0
 
@@ -30,7 +30,7 @@ class RemoteServerService:
 
     def __init__(
             self,
-            file_system_service: FileSystemServiceCore,
+            file_system_service: FileSystemService,
             config_provider: ConfigProvider,
     ):
         self.__file_system_service = file_system_service

thestage/services/service_factory.py

@@ -1,7 +1,7 @@
 from typing import Optional
 
 from thestage.services.connect.connect_service import ConnectService
-from thestage.services.filesystem_service import FileSystemServiceCore
+from thestage.services.filesystem_service import FileSystemService
 from thestage.services.logging.logging_service import LoggingService
 from thestage.services.project.project_service import ProjectService
 from thestage.services.remote_server_service import RemoteServerService
@@ -18,7 +18,7 @@ class ServiceFactory:
     __config_provider: Optional[ConfigProvider] = None
     __thestage_api_client: Optional[TheStageApiClient] = None
     __git_local_client: Optional[GitLocalClient] = None
-    __file_system_service: Optional[FileSystemServiceCore] = None
+    __file_system_service: Optional[FileSystemService] = None
 
     def __init__(
             self,
@@ -84,9 +84,9 @@ class ServiceFactory:
             self.__git_local_client = GitLocalClient(file_system_service=self.get_file_system_service())
         return self.__git_local_client
 
-    def get_file_system_service(self) -> FileSystemServiceCore:
+    def get_file_system_service(self) -> FileSystemService:
         if not self.__file_system_service:
-            self.__file_system_service = FileSystemServiceCore()
+            self.__file_system_service = FileSystemService()
         return self.__file_system_service
 
     def get_app_config_service(self, config_provider: Optional[ConfigProvider] = None,) -> AppConfigService:

thestage/services/validation_service.py

@@ -53,10 +53,4 @@ class ValidationService:
             if not config.main.thestage_auth_token:
                 present_token = False
 
-            if config.start_on_daemon:
-                if config.daemon and config.daemon.daemon_token:
-                    present_token = True
-                else:
-                    present_token = False
-
         return present_token

{thestage-0.5.44.dist-info → thestage-0.5.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: thestage
-Version: 0.5.44
+Version: 0.5.46
 Summary: 
 Author: TheStage AI team
 Author-email: hello@thestage.ai
@@ -21,7 +21,7 @@ Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-gettext-translations (>=1.1.0,<2.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
-Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
+Requires-Dist: typer[all] (>=0.15.2,<0.16.0)
 Description-Content-Type: text/markdown
 
 # Introduction