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

thestage/services/project/project_service.py

@@ -18,7 +18,6 @@ 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
 from thestage.exceptions.git_access_exception import GitAccessException
@@ -60,6 +59,7 @@ from rich import print
 
 class ProjectService(AbstractService):
     __thestage_api_client: TheStageApiClient = None
+    __config_provider: ConfigProvider = None
 
     def __init__(
             self,
@@ -69,9 +69,6 @@ class ProjectService(AbstractService):
             file_system_service: FileSystemService,
             git_local_client: GitLocalClient,
     ):
-        super(ProjectService, self).__init__(
-            config_provider=config_provider
-        )
         self.__thestage_api_client = thestage_api_client
         self.__remote_server_service = remote_server_service
         self.__file_system_service = file_system_service
@@ -83,12 +80,11 @@ class ProjectService(AbstractService):
     @error_handler()
     def init_project(
             self,
-            config: ConfigEntity,
             project_slug: str,
     ):
+        config = self.__config_provider.get_config()
         project: Optional[ProjectDto] = self.__thestage_api_client.get_project_by_slug(
             slug=project_slug,
-            token=config.main.thestage_auth_token,
         )
 
         if not project:
@@ -124,7 +120,6 @@ class ProjectService(AbstractService):
 
         deploy_ssh_key = self.__thestage_api_client.get_project_deploy_ssh_key(
             slug=project.slug,
-            token=config.main.thestage_auth_token
         )
 
         deploy_key_path = self.__config_provider.save_project_deploy_ssh_key(
@@ -167,16 +162,17 @@ class ProjectService(AbstractService):
         project_config.deploy_key_path = str(deploy_key_path)
         self.__config_provider.save_project_config(project_config=project_config)
 
+        typer.echo(__("Project successfully initialized at %path%", {"path": config.runtime.working_directory}))
+
 
     @error_handler()
     def clone_project(
             self,
-            config: ConfigEntity,
             project_slug: str,
     ):
+        config = self.__config_provider.get_config()
         project: Optional[ProjectDto] = self.__thestage_api_client.get_project_by_slug(
             slug=project_slug,
-            token=config.main.thestage_auth_token,
         )
 
         if not project:
@@ -199,7 +195,7 @@ class ProjectService(AbstractService):
             typer.echo(__("Unexpected Project error, missing Repository"))
             raise typer.Exit(1)
 
-        deploy_ssh_key = self.__thestage_api_client.get_project_deploy_ssh_key(slug=project.slug, token=config.main.thestage_auth_token)
+        deploy_ssh_key = self.__thestage_api_client.get_project_deploy_ssh_key(slug=project.slug)
         deploy_key_path = self.__config_provider.save_project_deploy_ssh_key(deploy_ssh_key=deploy_ssh_key, project_slug=project.slug, project_id=project.id)
 
         try:
@@ -226,18 +222,19 @@ class ProjectService(AbstractService):
         project_config.git_repository_url = project.git_repository_url
         project_config.deploy_key_path = str(deploy_key_path)
         self.__config_provider.save_project_config(project_config=project_config)
+        typer.echo(__("Project successfully cloned to %path%", {"path": config.runtime.working_directory}))
 
 
     @error_handler()
     def project_run_task(
             self,
-            config: ConfigEntity,
             run_command: str,
             task_title: Optional[str] = None,
             commit_hash: Optional[str] = None,
             docker_container_slug: Optional[str] = None,
     ) -> Optional[TaskDto]:
-        project_config: ProjectConfig = self.__get_fixed_project_config(config=config)
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
             typer.echo(__("No project found at the path: %path%. Please initialize or clone a project first.", {"path": config.runtime.working_directory}))
             raise typer.Exit(1)
@@ -252,7 +249,6 @@ class ProjectService(AbstractService):
             typer.echo(f"Using default docker container for this project: '{container_slug_for_task}'")
 
         container: DockerContainerDto = self.__thestage_api_client.get_container(
-            token=config.main.thestage_auth_token,
             container_slug=container_slug_for_task,
         )
 
@@ -384,7 +380,6 @@ class ProjectService(AbstractService):
             typer.echo(f'Commit message is empty. Task title is set to "{task_title}"')
 
         run_task_response: ProjectRunTaskResponse = self.__thestage_api_client.execute_project_task(
-            token=config.main.thestage_auth_token,
             project_slug=project_config.slug,
             docker_container_slug=container_slug_for_task,
             run_command=run_command,
@@ -405,9 +400,8 @@ class ProjectService(AbstractService):
             raise typer.Exit(1)
 
     @error_handler()
-    def cancel_task(self, task_id: int, config: ConfigEntity):
+    def cancel_task(self, task_id: int):
         cancel_result = self.__thestage_api_client.cancel_task(
-            token=config.main.thestage_auth_token,
             task_id=task_id,
         )
 
@@ -420,7 +414,6 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_run_inference_simulator(
             self,
-            config: ConfigEntity,
             slug: Optional[str] = None,
             commit_hash: Optional[str] = None,
             rented_instance_unique_id: Optional[str] = None,
@@ -428,7 +421,8 @@ class ProjectService(AbstractService):
             inference_dir: Optional[str] = None,
             is_skip_installation: Optional[bool] = False,
     ) -> Optional[InferenceSimulatorDto]:
-        project_config: ProjectConfig = self.__get_fixed_project_config(config=config)
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
             typer.echo(__("No project found at the path: %path%. Please initialize or clone a project first. Or provide path to project using --working-directory option.",
                           {"path": config.runtime.working_directory}))
@@ -442,12 +436,6 @@ class ProjectService(AbstractService):
             typer.echo(__("Error: Either a rented instance ID or a self-hosted instance unique ID must be provided."))
             raise typer.Exit(1)
 
-        project_config: ProjectConfig = self.__config_provider.read_project_config()
-        if not project_config:
-            typer.echo(__("No project found at the path: %path%. Please initialize or clone a project first.",
-                          {"path": config.runtime.working_directory}))
-            raise typer.Exit(1)
-
         if not commit_hash:
             is_git_folder = self.__git_local_client.is_present_local_git(path=config.runtime.working_directory)
             if not is_git_folder:
@@ -555,7 +543,6 @@ class ProjectService(AbstractService):
                 slug = uid
 
         start_inference_simulator_response: ProjectStartInferenceSimulatorResponse = self.__thestage_api_client.start_project_inference_simulator(
-            token=config.main.thestage_auth_token,
             project_slug=project_config.slug,
             commit_hash=commit_hash,
             slug=slug,
@@ -584,12 +571,10 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_push_inference_simulator(
             self,
-            config: ConfigEntity,
             slug: Optional[str] = None,
     ):
 
         push_inference_simulator_model_response: ProjectPushInferenceSimulatorModelResponse = self.__thestage_api_client.push_project_inference_simulator_model(
-            token=config.main.thestage_auth_token,
             slug=slug,
         )
         if push_inference_simulator_model_response:
@@ -610,12 +595,10 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_get_and_save_inference_simulator_metadata(
             self,
-            config: ConfigEntity,
             slug: Optional[str] = None,
             file_path: Optional[str] = None,
     ):
         get_inference_metadata_response: GetInferenceSimulatorResponse = self.__thestage_api_client.get_inference_simulator(
-            token=config.main.thestage_auth_token,
             slug=slug,
         )
 
@@ -649,14 +632,12 @@ class ProjectService(AbstractService):
     @error_handler()
     def get_project_inference_simulator_list(
             self,
-            config: ConfigEntity,
             project_slug: str,
             statuses: List[str],
             row: int = 5,
             page: int = 1,
     ) -> PaginatedEntityList[InferenceSimulatorDto]:
         data: Optional[PaginatedEntityList[InferenceSimulatorDto]] = self.__thestage_api_client.get_inference_simulator_list_for_project(
-            token=config.main.thestage_auth_token,
             statuses=statuses,
             project_slug=project_slug,
             page=page,
@@ -669,7 +650,6 @@ class ProjectService(AbstractService):
     @error_handler()
     def get_project_inference_simulator_model_list(
             self,
-            config: ConfigEntity,
             project_slug: str,
             statuses: List[str],
             row: int = 5,
@@ -677,7 +657,6 @@ class ProjectService(AbstractService):
     ) -> PaginatedEntityList[InferenceSimulatorModelDto]:
         data: Optional[
             PaginatedEntityList[InferenceSimulatorModelDto]] = self.__thestage_api_client.get_inference_simulator_model_list_for_project(
-            token=config.main.thestage_auth_token,
             statuses=statuses,
             project_slug=project_slug,
             page=page,
@@ -690,13 +669,11 @@ class ProjectService(AbstractService):
     @error_handler()
     def get_project_task_list(
             self,
-            config: ConfigEntity,
             project_slug: str,
             row: int = 5,
             page: int = 1,
     ) -> PaginatedEntityList[TaskDto]:
         data: Optional[PaginatedEntityList[TaskDto]] = self.__thestage_api_client.get_task_list_for_project(
-            token=config.main.thestage_auth_token,
             project_slug=project_slug,
             page=page,
             limit=row,
@@ -708,11 +685,11 @@ class ProjectService(AbstractService):
     @error_handler()
     def checkout_project(
             self,
-            config: ConfigEntity,
             task_id: Optional[int],
             branch_name: Optional[str],
     ):
-        project_config: ProjectConfig = self.__get_fixed_project_config(config=config)
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
             typer.echo(__("This command is only allowed from within an initialized project directory"))
             raise typer.Exit(1)
@@ -721,10 +698,7 @@ class ProjectService(AbstractService):
         if task_id:
             task_view_response: Optional[TaskViewResponse] = None
             try:
-                task_view_response = self.__thestage_api_client.get_task(
-                    token=config.main.thestage_auth_token,
-                    task_id=task_id,
-                )
+                task_view_response = self.__thestage_api_client.get_task(task_id=task_id,)
             except HttpClientException as e:
                 if e.get_status_code() == 400:
                     typer.echo(f"Task {task_id} was not found")
@@ -847,7 +821,7 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def set_default_container(self, config: ConfigEntity, container_uid: Optional[str]):
+    def set_default_container(self, container_uid: Optional[str]):
         project_config: ProjectConfig = self.__config_provider.read_project_config()
 
         if project_config is None:
@@ -856,7 +830,6 @@ class ProjectService(AbstractService):
 
         if container_uid:
             container: DockerContainerDto = self.__thestage_api_client.get_container(
-                token=config.main.thestage_auth_token,
                 container_slug=container_uid,
             )
             if container is None:
@@ -891,7 +864,7 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def print_project_config(self, config):
+    def print_project_config(self):
         project_config: ProjectConfig = self.__config_provider.read_project_config()
 
         if project_config is None:
@@ -923,7 +896,7 @@ class ProjectService(AbstractService):
             typer.echo(f"before any regular git command to manage your local Project repository directly")
 
     @error_handler()
-    def __get_fixed_project_config(self, config: ConfigEntity) -> Optional[ProjectConfig]:
+    def __get_fixed_project_config(self) -> Optional[ProjectConfig]:
         project_config: ProjectConfig = self.__config_provider.read_project_config()
         if project_config is None:
             return None
@@ -931,7 +904,6 @@ class ProjectService(AbstractService):
         if not Path(project_config.deploy_key_path).is_file():
             deploy_ssh_key = self.__thestage_api_client.get_project_deploy_ssh_key(
                 slug=project_config.slug,
-                token=config.main.thestage_auth_token
             )
 
             deploy_key_path = self.__config_provider.save_project_deploy_ssh_key(
@@ -949,13 +921,13 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_deploy_inference_simulator_model_to_instance(
             self,
-            config: ConfigEntity,
             unique_id: Optional[str] = None,
             unique_id_with_timestamp: Optional[str] = None,
             rented_instance_unique_id: Optional[str] = None,
             self_hosted_instance_unique_id: Optional[str] = None,
     ) -> None:
-        project_config: ProjectConfig = self.__get_fixed_project_config(config=config)
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
             typer.echo(
                 __("No project found at the path: %path%. Please initialize or clone a project first. Or provide path to project using --working-directory option.",
@@ -970,15 +942,8 @@ class ProjectService(AbstractService):
             typer.echo(__("Error: Either a rented instance ID or a self-hosted instance unique ID must be provided."))
             raise typer.Exit(1)
 
-        project_config: ProjectConfig = self.__config_provider.read_project_config()
-        if not project_config:
-            typer.echo(__("No project found at the path: %path%. Please initialize or clone a project first.",
-                          {"path": config.runtime.working_directory}))
-            raise typer.Exit(1)
-
         typer.echo(__("Creating inference simulator with unique ID: %unique_id_with_timestamp%", {"unique_id_with_timestamp": unique_id_with_timestamp}))
         deploy_model_to_instance_response: DeployInferenceModelToInstanceResponse = self.__thestage_api_client.deploy_inference_model_to_instance(
-            token=config.main.thestage_auth_token,
             unique_id=unique_id,
             unique_id_with_timestamp=unique_id_with_timestamp,
             rented_instance_unique_id=rented_instance_unique_id,
@@ -1003,14 +968,14 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_deploy_inference_simulator_model_to_sagemaker(
             self,
-            config: ConfigEntity,
             unique_id: Optional[str] = None,
             arn: Optional[str] = None,
             instance_type: Optional[str] = None,
             initial_variant_weight: Optional[float] = 1.0,
             initial_instance_count: Optional[int] = None,
     ) -> None:
-        project_config: ProjectConfig = self.__get_fixed_project_config(config=config)
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
             typer.echo(
                 __("No project found at the path: %path%. Please initialize or clone a project first. Or provide path to project using --working-directory option.",
@@ -1036,7 +1001,6 @@ class ProjectService(AbstractService):
             raise typer.Exit(1)
 
         deploy_model_to_sagemaker_response: DeployInferenceModelToSagemakerResponse = self.__thestage_api_client.deploy_inference_model_to_sagemaker(
-            token=config.main.thestage_auth_token,
             unique_id=unique_id,
             arn=arn,
         )
@@ -1116,8 +1080,9 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def pull_project(self, config: ConfigEntity):
-        project_config: ProjectConfig = self.__get_fixed_project_config(config=config)
+    def pull_project(self):
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
             typer.echo(__("No project found at the path: %path%. Please initialize or clone a project first.", {"path": config.runtime.working_directory}))
             raise typer.Exit(1)
@@ -1130,8 +1095,9 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def reset_project(self, config: ConfigEntity):
-        project_config: ProjectConfig = self.__get_fixed_project_config(config=config)
+    def reset_project(self):
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
             typer.echo(__("No project found at the path: %path%. Please initialize or clone a project first.", {"path": config.runtime.working_directory}))
             raise typer.Exit(1)
@@ -1150,7 +1116,7 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def print_inference_simulator_list(self, config, project_uid, statuses, row, page):
+    def print_inference_simulator_list(self, project_uid, statuses, row, page):
         if not project_uid:
             project_config: ProjectConfig = self.__config_provider.read_project_config()
             if not project_config:
@@ -1158,8 +1124,7 @@ class ProjectService(AbstractService):
                 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)
+        inference_simulator_status_map = self.__thestage_api_client.get_inference_simulator_business_status_map()
 
         if not statuses:
             statuses = ({key: inference_simulator_status_map[key] for key in [
@@ -1194,7 +1159,6 @@ class ProjectService(AbstractService):
                 'statuses': backend_statuses,
             },
             mapper=ProjectInferenceSimulatorMapper(),
-            config=config,
             headers=list(map(lambda x: x.alias, ProjectInferenceSimulatorEntity.model_fields.values())),
             row=row,
             page=page,
@@ -1204,7 +1168,7 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def print_inference_simulator_model_list(self, config, project_uid, statuses, row, page):
+    def print_inference_simulator_model_list(self, project_uid, statuses, row, page):
         if not project_uid:
             project_config: ProjectConfig = self.__config_provider.read_project_config()
             if not project_config:
@@ -1212,8 +1176,7 @@ class ProjectService(AbstractService):
                 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)
+        inference_simulator_model_status_map = self.__thestage_api_client.get_inference_simulator_model_business_status_map()
 
         if not statuses:
             statuses = ({key: inference_simulator_model_status_map[key] for key in [
@@ -1248,7 +1211,6 @@ class ProjectService(AbstractService):
                 'statuses': backend_statuses,
             },
             mapper=ProjectInferenceSimulatorModelMapper(),
-            config=config,
             headers=list(map(lambda x: x.alias, ProjectInferenceSimulatorModelEntity.model_fields.values())),
             row=row,
             page=page,
@@ -1257,7 +1219,7 @@ class ProjectService(AbstractService):
         )
 
 
-    def print_task_list(self, config: ConfigEntity, project_uid, row, page):
+    def print_task_list(self, project_uid, row, page):
         if not project_uid:
             project_config: ProjectConfig = self.__config_provider.read_project_config()
             if not project_config:
@@ -1271,7 +1233,6 @@ class ProjectService(AbstractService):
                 'project_slug': project_uid,
             },
             mapper=ProjectTaskMapper(),
-            config=config,
             headers=list(map(lambda x: x.alias, ProjectTaskEntity.model_fields.values())),
             row=row,
             page=page,

thestage/services/remote_server_service.py

@@ -27,6 +27,8 @@ old_value: int = 0
 
 
 class RemoteServerService:
+    __config_provider: ConfigProvider = None
+    __file_system_service: FileSystemService = None
 
     def __init__(
             self,
@@ -490,9 +492,9 @@ class RemoteServerService:
             dest_path: str,
             instance_path: str,
             copy_only_folder_contents: bool,
-            config: ConfigEntity,
             depth: int = 0,
     ) -> List[SftpFileItemEntity]:
+        config = self.__config_provider.get_config()
         path_items = []
         try:
             root_stat = sftp.stat(current_path)
@@ -547,7 +549,6 @@ class RemoteServerService:
                             instance_path=parent.instance_path,
                             depth=depth + 1,
                             copy_only_folder_contents=copy_only_folder_contents,
-                            config=config,
                         ))
             return path_items
         except FileNotFoundError as ex:
@@ -568,7 +569,6 @@ class RemoteServerService:
             instance_path: str,
             copy_only_folder_contents: bool,
             private_key_path: Optional[str],
-            config: ConfigEntity,
     ):
         has_error = False
 
@@ -581,7 +581,6 @@ class RemoteServerService:
                 instance_path=instance_path,
                 dest_path=dest_path,
                 copy_only_folder_contents=copy_only_folder_contents,
-                config=config,
             )
 
             if len(files) == 0:

thestage/services/service_factory.py

@@ -1,5 +1,6 @@
 from typing import Optional
 
+from thestage.services.config_provider.config_provider import ConfigProvider
 from thestage.services.connect.connect_service import ConnectService
 from thestage.services.filesystem_service import FileSystemService
 from thestage.services.logging.logging_service import LoggingService
@@ -10,73 +11,63 @@ from thestage.services.instance.instance_service import InstanceService
 from thestage.services.app_config_service import AppConfigService
 from thestage.services.clients.git.git_client import GitLocalClient
 from thestage.services.clients.thestage_api.api_client import TheStageApiClient
-from thestage.services.config_provider.config_provider import ConfigProvider
 from thestage.services.validation_service import ValidationService
 
 
 class ServiceFactory:
-    __config_provider: Optional[ConfigProvider] = None
     __thestage_api_client: Optional[TheStageApiClient] = None
     __git_local_client: Optional[GitLocalClient] = None
     __file_system_service: Optional[FileSystemService] = None
+    __config_provider: Optional[ConfigProvider] = None
 
-    def __init__(
-            self,
-            config_provider: Optional[ConfigProvider] = None,
-    ):
-        self.__config_provider = config_provider
-
-    def get_config_provider(self) -> ConfigProvider:
-        return self.__config_provider
 
-    def get_validation_service(self, config_provider: Optional[ConfigProvider] = None,) -> ValidationService:
+    def get_validation_service(self) -> ValidationService:
         return ValidationService(
                 thestage_api_client=self.get_thestage_api_client(),
-                config_provider=config_provider if config_provider else self.__config_provider,
+                config_provider=self.get_config_provider(),
             )
 
-    def get_instance_service(self, config_provider: Optional[ConfigProvider] = None) -> InstanceService:
+    def get_instance_service(self) -> InstanceService:
         return InstanceService(
                 thestage_api_client=self.get_thestage_api_client(),
-                config_provider=config_provider if config_provider else self.__config_provider,
                 remote_server_service=self.get_remote_server_service(),
+                config_provider=self.get_config_provider(),
             )
 
-    def get_container_service(self, config_provider: Optional[ConfigProvider] = None) -> ContainerService:
+    def get_container_service(self) -> ContainerService:
         return ContainerService(
                 thestage_api_client=self.get_thestage_api_client(),
-                config_provider=config_provider if config_provider else self.__config_provider,
                 remote_server_service=self.get_remote_server_service(),
                 file_system_service=self.get_file_system_service(),
+                config_provider=self.get_config_provider(),
             )
 
-    def get_connect_service(self, config_provider: Optional[ConfigProvider] = None) -> ConnectService:
+    def get_connect_service(self) -> ConnectService:
         return ConnectService(
-            config_provider=config_provider if config_provider else self.__config_provider,
             thestage_api_client=self.get_thestage_api_client(),
             instance_service=self.get_instance_service(),
             container_service=self.get_container_service(),
             logging_service=self.get_logging_service(),
         )
 
-    def get_project_service(self, config_provider: Optional[ConfigProvider] = None) -> ProjectService:
+    def get_project_service(self) -> ProjectService:
         return ProjectService(
             thestage_api_client=self.get_thestage_api_client(),
-            config_provider=config_provider if config_provider else self.__config_provider,
             remote_server_service=self.get_remote_server_service(),
             file_system_service=self.get_file_system_service(),
             git_local_client=self.get_git_local_client(),
+            config_provider=self.get_config_provider(),
         )
 
     def get_remote_server_service(self) -> RemoteServerService:
         return RemoteServerService(
-            config_provider=self.get_config_provider(),
             file_system_service=self.get_file_system_service(),
+            config_provider=self.get_config_provider(),
         )
 
     def get_thestage_api_client(self) -> TheStageApiClient:
         if not self.__thestage_api_client:
-            self.__thestage_api_client = TheStageApiClient(api_url=self.__config_provider.get_full_config().main.thestage_api_url)
+            self.__thestage_api_client = TheStageApiClient(config_provider=self.get_config_provider())
         return self.__thestage_api_client
 
     def get_git_local_client(self):
@@ -89,15 +80,18 @@ class ServiceFactory:
             self.__file_system_service = FileSystemService()
         return self.__file_system_service
 
-    def get_app_config_service(self, config_provider: Optional[ConfigProvider] = None,) -> AppConfigService:
+    def get_app_config_service(self) -> AppConfigService:
         return AppConfigService(
-            validation_service=self.get_validation_service(config_provider),
-            config_provider=config_provider if config_provider else self.__config_provider,
+            config_provider=self.get_config_provider(),
+            validation_service=self.get_validation_service(),
         )
 
-    def get_logging_service(self, config_provider: Optional[ConfigProvider] = None) -> LoggingService:
+    def get_logging_service(self) -> LoggingService:
         return LoggingService(
             thestage_api_client=self.get_thestage_api_client(),
-            config_provider=config_provider if config_provider else self.__config_provider,
         )
 
+    def get_config_provider(self) -> ConfigProvider:
+        if not self.__config_provider:
+            self.__config_provider = ConfigProvider(self.get_file_system_service())
+        return self.__config_provider

thestage/services/validation_service.py

@@ -1,13 +1,15 @@
 import typer
 
 from thestage.i18n.translation import __
-from thestage.services.config_provider.config_provider import ConfigProvider
+# from thestage.main import update_allowed_commands
 from thestage.services.clients.thestage_api.api_client import TheStageApiClient
+from thestage.services.config_provider.config_provider import ConfigProvider
 from thestage.services.core_files.config_entity import ConfigEntity
 
 
 class ValidationService:
     _thestage_api_client: TheStageApiClient = None
+    _config_provider: ConfigProvider = None
 
     def __init__(
             self,
@@ -18,10 +20,8 @@ class ValidationService:
         self._config_provider = config_provider
 
 
-    def check_token(
-            self,
-            config: ConfigEntity,
-    ):
+    def check_token(self):
+        config = self._config_provider.get_config()
         token = config.main.thestage_auth_token
         if not token:
             token: str = typer.prompt(
@@ -32,16 +32,21 @@ class ValidationService:
             )
 
 # TODO this fails with 503 error - AttributeError("'bytes' object has no attribute 'text'") from _parse_api_response method in core
-        is_valid: bool = False
-        if token:
-            is_valid = self._thestage_api_client.validate_token(token=token)
+        if not token:
+            return
+
+        token_validate_response = self._thestage_api_client.validate_token(token=token)
+        is_valid = token_validate_response.is_success if token_validate_response else False
         if not is_valid:
             typer.echo(__(
                 'API token is invalid: generate API token using TheStage AI WebApp'
             ))
             raise typer.Exit(1)
 
-        config.main.thestage_auth_token = token
+        if config.main.thestage_auth_token != token:
+            config.main.thestage_auth_token = token
+            self._config_provider.update_config(updated_config=config)
+            self._config_provider.update_allowed_commands_and_is_token_valid(validate_token_response=token_validate_response)
 
 
     @staticmethod