thestage 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

thestage/services/project/project_service.py

@@ -80,11 +80,13 @@ class ProjectService(AbstractService):
     @error_handler()
     def init_project(
             self,
-            project_slug: str,
+            project_slug: Optional[str] = None,
+            project_public_id: Optional[str] = None,
     ):
         config = self.__config_provider.get_config()
-        project: Optional[ProjectDto] = self.__thestage_api_client.get_project_by_slug(
+        project: Optional[ProjectDto] = self.__thestage_api_client.get_project(
             slug=project_slug,
+            public_id=project_public_id,
         )
 
         if not project:
@@ -119,13 +121,12 @@ class ProjectService(AbstractService):
                 raise typer.Exit(0)
 
         deploy_ssh_key = self.__thestage_api_client.get_project_deploy_ssh_key(
-            slug=project.slug,
+            public_id=project.public_id,
         )
 
         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,
+            project_public_id=project.public_id,
         )
 
         if is_git_folder:
@@ -156,7 +157,7 @@ class ProjectService(AbstractService):
         self.__git_local_client.git_add_all(repo_path=config.runtime.working_directory)
 
         project_config = ProjectConfig()
-        project_config.id = project.id
+        project_config.public_id = project.public_id
         project_config.slug = project.slug
         project_config.git_repository_url = project.git_repository_url
         project_config.deploy_key_path = str(deploy_key_path)
@@ -169,10 +170,12 @@ class ProjectService(AbstractService):
     def clone_project(
             self,
             project_slug: str,
+            project_public_id: str
     ):
         config = self.__config_provider.get_config()
-        project: Optional[ProjectDto] = self.__thestage_api_client.get_project_by_slug(
+        project: Optional[ProjectDto] = self.__thestage_api_client.get_project(
             slug=project_slug,
+            public_id=project_public_id
         )
 
         if not project:
@@ -195,8 +198,8 @@ 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)
-        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)
+        deploy_ssh_key = self.__thestage_api_client.get_project_deploy_ssh_key(public_id=project.public_id)
+        deploy_key_path = self.__config_provider.save_project_deploy_ssh_key(deploy_ssh_key=deploy_ssh_key, project_public_id=project.public_id,)
 
         try:
             self.__git_local_client.clone(
@@ -217,7 +220,7 @@ class ProjectService(AbstractService):
             raise typer.Exit(1)
 
         project_config = ProjectConfig()
-        project_config.id = project.id
+        project_config.public_id = project.public_id
         project_config.slug = project.slug
         project_config.git_repository_url = project.git_repository_url
         project_config.deploy_key_path = str(deploy_key_path)
@@ -229,9 +232,10 @@ class ProjectService(AbstractService):
     def project_run_task(
             self,
             run_command: str,
+            docker_container_slug: str,
+            docker_container_public_id: str,
             task_title: Optional[str] = None,
             commit_hash: Optional[str] = None,
-            docker_container_slug: Optional[str] = None,
             files_to_add: Optional[str] = None,
             is_skip_auto_commit: Optional[bool] = False,
     ) -> Optional[TaskDto]:
@@ -241,43 +245,48 @@ class ProjectService(AbstractService):
             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 docker_container_slug and not project_config.default_container_uid:
-            typer.echo(__('Docker container unique ID is required'))
+        if not docker_container_public_id and not docker_container_slug and not project_config.default_container_public_id:
+            typer.echo(__('Docker container ID or name is required'))
             raise typer.Exit(1)
 
-        container_slug_for_task = docker_container_slug if docker_container_slug else project_config.default_container_uid
-
-        if not docker_container_slug:
-            typer.echo(f"Using default docker container for this project: '{container_slug_for_task}'")
+        final_container_public_id = docker_container_public_id
+        final_container_slug = docker_container_slug
+        if not final_container_public_id and not final_container_slug:
+            final_container_public_id = project_config.default_container_public_id
+            typer.echo(f"Using default docker container for this project: '{project_config.default_container_public_id}'")
 
         container: DockerContainerDto = self.__thestage_api_client.get_container(
-            container_slug=container_slug_for_task,
+            container_slug=final_container_slug,
+            container_public_id=final_container_public_id
         )
 
         if container is None:
-            typer.echo(f"Could not find container '{container_slug_for_task}'")
-            if project_config.default_container_uid == container_slug_for_task:
-                project_config.default_container_uid = None
+            if final_container_slug:
+                typer.echo(f"Could not find container with name '{final_container_slug}'")
+            if final_container_public_id:
+                typer.echo(f"Could not find container with ID '{final_container_public_id}'")
+            if project_config.default_container_public_id == final_container_public_id:
+                project_config.default_container_public_id = None
                 project_config.prompt_for_default_container = True
                 self.__config_provider.save_project_config(project_config=project_config)
                 typer.echo(f"Default container settings were reset")
             raise typer.Exit(1)
 
-        if container.project_id != project_config.id:
-            typer.echo(f"Provided container '{docker_container_slug}' is not related to project '{project_config.slug}'")
+        if container.project.public_id != project_config.public_id:
+            typer.echo(f"Provided container '{container.public_id}' is not related to project '{project_config.public_id}'")
             raise typer.Exit(1)
 
-        if (project_config.prompt_for_default_container is None or project_config.prompt_for_default_container) and docker_container_slug and (project_config.default_container_uid != docker_container_slug):
-            set_default_container_slug: str = typer.prompt(
-                text=f"Would you like to set '{docker_container_slug}' as a default container for this project installation?",
+        if (project_config.prompt_for_default_container is None or project_config.prompt_for_default_container) and (docker_container_slug or docker_container_public_id) and (project_config.default_container_public_id != container.public_id):
+            set_default_container_answer: str = typer.prompt(
+                text=f"Would you like to set the container '{container.slug}' (ID: '{container.public_id}') as default for this project installation?",
                 show_choices=True,
                 default=YesOrNoResponse.YES.value,
                 type=click.Choice([r.value for r in YesOrNoResponse]),
                 show_default=True,
             )
             project_config.prompt_for_default_container = False
-            if set_default_container_slug == YesOrNoResponse.YES.value:
-                project_config.default_container_uid = docker_container_slug
+            if set_default_container_answer == YesOrNoResponse.YES.value:
+                project_config.default_container_public_id = container.public_id
 
             self.__config_provider.save_project_config(project_config=project_config)
 
@@ -395,8 +404,8 @@ 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(
-            project_slug=project_config.slug,
-            docker_container_slug=container_slug_for_task,
+            project_public_id=project_config.public_id,
+            docker_container_public_id=container.public_id,
             run_command=run_command,
             commit_hash=commit_hash,
             task_title=task_title,
@@ -405,7 +414,11 @@ class ProjectService(AbstractService):
             if run_task_response.message:
                 print(f"[{ColorScheme.WARNING.value}]{run_task_response.message}[{ColorScheme.WARNING.value}]")
             if run_task_response.is_success and run_task_response.task:
-                typer.echo(f"Task '{run_task_response.task.title}' has been scheduled successfully. Task ID: {run_task_response.task.id}")
+                typer.echo(f"Task '{run_task_response.task.title}' has been scheduled successfully. Task ID: {run_task_response.task.public_id}")
+                if run_task_response.tasksInQueue:
+                    typer.echo(f"There are tasks in queue ahead of this new task:")
+                    for queued_task_item in run_task_response.tasksInQueue:
+                        typer.echo(f"{queued_task_item.public_id} - {queued_task_item.frontend_status.status_translation}")
                 return run_task_response.task
             else:
                 typer.echo(f'The task failed with an error: {run_task_response.message}')
@@ -415,23 +428,25 @@ class ProjectService(AbstractService):
             raise typer.Exit(1)
 
     @error_handler()
-    def cancel_task(self, task_id: int):
+    def cancel_task(self, task_public_id: str):
         cancel_result = self.__thestage_api_client.cancel_task(
-            task_id=task_id,
+            task_public_id=task_public_id,
         )
 
         if cancel_result.is_success:
-            typer.echo(f'Task {task_id} has been canceled')
+            typer.echo(f'Task {task_public_id} has been canceled')
         else:
-            typer.echo(f'Task {task_id} could not be canceled: {cancel_result.message}')
+            typer.echo(f'Task {task_public_id} could not be canceled: {cancel_result.message}')
 
 
     @error_handler()
     def project_run_inference_simulator(
             self,
             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,
             files_to_add: Optional[str] = None,
@@ -444,16 +459,12 @@ class ProjectService(AbstractService):
                           {"path": config.runtime.working_directory}))
             raise typer.Exit(1)
 
-        if rented_instance_unique_id and self_hosted_instance_unique_id:
-            typer.echo(__("Error: Cannot provide both rented and self-hosted instance unique IDs."))
-            raise typer.Exit(1)
-
-        if not rented_instance_unique_id and not self_hosted_instance_unique_id:
-            typer.echo(__("Error: Either a rented instance ID or a self-hosted instance unique ID must be provided."))
+        instance_args_count = sum(v is not None for v in [rented_instance_public_id, rented_instance_slug, self_hosted_instance_public_id, self_hosted_instance_slug])
+        if instance_args_count != 1:
+            typer.echo("Please provide a single instance (rented or self-hosted) identifier - name or ID.")
             raise typer.Exit(1)
 
         has_wrong_args = files_to_add and commit_hash or is_skip_auto_commit and commit_hash or files_to_add and is_skip_auto_commit
-
         if has_wrong_args:
             warning_msg = f"[{ColorScheme.WARNING.value}][WARNING] You can provide only one of the following arguments: --commit-hash, --files-add, --skip-autocommit[{ColorScheme.WARNING.value}]"
             print(warning_msg)
@@ -555,10 +566,12 @@ class ProjectService(AbstractService):
                 commit_hash = commit.hexsha
 
         start_inference_simulator_response: ProjectStartInferenceSimulatorResponse = self.__thestage_api_client.start_project_inference_simulator(
-            project_slug=project_config.slug,
+            project_public_id=project_config.public_id,
             commit_hash=commit_hash,
-            rented_instance_unique_id=rented_instance_unique_id,
-            self_hosted_instance_unique_id=self_hosted_instance_unique_id,
+            rented_instance_public_id=rented_instance_public_id,
+            rented_instance_slug=rented_instance_slug,
+            self_hosted_instance_public_id=self_hosted_instance_public_id,
+            self_hosted_instance_slug=self_hosted_instance_slug,
             inference_dir=inference_dir,
             is_skip_installation=is_skip_installation,
         )
@@ -582,10 +595,12 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_push_inference_simulator(
             self,
+            public_id: Optional[str] = None,
             slug: Optional[str] = None,
     ):
 
         push_inference_simulator_model_response: ProjectPushInferenceSimulatorModelResponse = self.__thestage_api_client.push_project_inference_simulator_model(
+            public_id=public_id,
             slug=slug,
         )
         if push_inference_simulator_model_response:
@@ -606,25 +621,27 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_get_and_save_inference_simulator_metadata(
             self,
-            slug: Optional[str] = None,
+            inference_simulator_public_id: Optional[str] = None,
+            inference_simulator_slug: Optional[str] = None,
             file_path: Optional[str] = None,
     ):
         get_inference_metadata_response: GetInferenceSimulatorResponse = self.__thestage_api_client.get_inference_simulator(
-            slug=slug,
+            public_id=inference_simulator_public_id,
+            slug=inference_simulator_slug,
         )
 
         metadata = get_inference_metadata_response.inferenceSimulator.qlip_serve_metadata
 
         if metadata:
             typer.echo("qlip_serve_metadata:")
-            typer.echo(json.dumps(json.loads(metadata), indent=4))
+            typer.echo(json.dumps(metadata, indent=4))
 
             if not file_path:
                 file_path = Path(os.getcwd()) / "metadata.json"
                 typer.echo(__("No file path provided. Saving metadata to %file_path%", {"file_path": str(file_path)}))
 
             try:
-                parsed_metadata = json.loads(metadata)
+                parsed_metadata = metadata
 
                 output_file = Path(file_path)
                 output_file.parent.mkdir(parents=True, exist_ok=True)
@@ -643,13 +660,15 @@ class ProjectService(AbstractService):
     @error_handler()
     def get_project_inference_simulator_list(
             self,
-            project_slug: str,
+            project_public_id: Optional[str],
+            project_slug: Optional[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(
+        data: Optional[PaginatedEntityList[InferenceSimulatorDto]] = self.__thestage_api_client.get_inference_simulator_list(
             statuses=statuses,
+            project_public_id=project_public_id,
             project_slug=project_slug,
             page=page,
             limit=row,
@@ -661,7 +680,8 @@ class ProjectService(AbstractService):
     @error_handler()
     def get_project_inference_simulator_model_list(
             self,
-            project_slug: str,
+            project_public_id: Optional[str],
+            project_slug: Optional[str],
             statuses: List[str],
             row: int = 5,
             page: int = 1,
@@ -669,22 +689,7 @@ class ProjectService(AbstractService):
         data: Optional[
             PaginatedEntityList[InferenceSimulatorModelDto]] = self.__thestage_api_client.get_inference_simulator_model_list_for_project(
             statuses=statuses,
-            project_slug=project_slug,
-            page=page,
-            limit=row,
-        )
-
-        return data
-
-
-    @error_handler()
-    def get_project_task_list(
-            self,
-            project_slug: str,
-            row: int = 5,
-            page: int = 1,
-    ) -> PaginatedEntityList[TaskDto]:
-        data: Optional[PaginatedEntityList[TaskDto]] = self.__thestage_api_client.get_task_list_for_project(
+            project_public_id=project_public_id,
             project_slug=project_slug,
             page=page,
             limit=row,
@@ -696,7 +701,7 @@ class ProjectService(AbstractService):
     @error_handler()
     def checkout_project(
             self,
-            task_id: Optional[int],
+            task_public_id: Optional[str],
             branch_name: Optional[str],
     ):
         config = self.__config_provider.get_config()
@@ -706,21 +711,21 @@ class ProjectService(AbstractService):
             raise typer.Exit(1)
 
         target_commit_hash: Optional[str] = None
-        if task_id:
+        if task_public_id:
             task_view_response: Optional[TaskViewResponse] = None
             try:
-                task_view_response = self.__thestage_api_client.get_task(task_id=task_id,)
+                task_view_response = self.__thestage_api_client.get_task(task_public_id=task_public_id)
             except HttpClientException as e:
                 if e.get_status_code() == 400:
-                    typer.echo(f"Task {task_id} was not found")
+                    typer.echo(f"Task {task_public_id} was not found")
                     # overriding arguments here
-                    branch_name = str(task_id)
-                    task_id = None
+                    branch_name = str(task_public_id)
+                    task_public_id = None
 
             if task_view_response and task_view_response.task:
                 target_commit_hash = task_view_response.task.commit_hash
                 if not target_commit_hash:
-                    typer.echo(f"Provided task ({task_id}) has no commit hash")  # possible legacy problems
+                    typer.echo(f"Provided task ({task_public_id}) has no commit hash")  # possible legacy problems
                     raise typer.Exit(1)
 
         is_commit_allowed: bool = True
@@ -833,48 +838,40 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def set_default_container(self, container_uid: Optional[str]):
+    def set_default_container(
+            self,
+            container_public_id: Optional[str],
+            container_slug: Optional[str],
+    ):
         project_config: ProjectConfig = self.__config_provider.read_project_config()
 
         if project_config is None:
             typer.echo(f"No project found in working directory")
             raise typer.Exit(1)
 
-        if container_uid:
+        container: Optional[DockerContainerDto] = None
+        if container_slug or container_public_id:
             container: DockerContainerDto = self.__thestage_api_client.get_container(
-                container_slug=container_uid,
+                container_public_id=container_public_id,
+                container_slug=container_slug,
             )
             if container is None:
-                typer.echo(f"Could not find container '{container_uid}'")
+                typer.echo(f"Could not find container '{container_slug or container_public_id}'")
                 raise typer.Exit(1)
 
-            if container.project_id != project_config.id:
-                typer.echo(f"Provided container '{container_uid}' is not related to project '{project_config.slug}'")
+            if container.project.public_id != project_config.public_id:
+                typer.echo(f"Provided container '{container_slug or container_public_id}' is not related to current project '{project_config.public_id}'")
                 raise typer.Exit(1)
 
             if container.frontend_status.status_key != DockerContainerStatus.RUNNING:
-                typer.echo(f"Note: provided container '{container_uid}' is in status '{container.frontend_status.status_translation}'")
+                typer.echo(f"Note: provided container '{container_slug or container_public_id}' is in status '{container.frontend_status.status_translation}'")
 
-        project_config.default_container_uid = container_uid
+        project_config.default_container_public_id = container.public_id if container else None
         project_config.prompt_for_default_container = False
         self.__config_provider.save_project_config(project_config=project_config)
         typer.echo("Default container settings were updated")
 
 
-    @error_handler()
-    def unset_default_container(self):
-        project_config: ProjectConfig = self.__config_provider.read_project_config()
-
-        if project_config is None:
-            typer.echo(f"No project found in working directory")
-            raise typer.Exit(1)
-
-        project_config.default_container_uid = None
-        project_config.prompt_for_default_container = True  # True or False?
-        self.__config_provider.save_project_config(project_config=project_config)
-        typer.echo("Default container settings were updated")
-
-
     @error_handler()
     def print_project_config(self):
         project_config: ProjectConfig = self.__config_provider.read_project_config()
@@ -888,10 +885,13 @@ class ProjectService(AbstractService):
         typer.echo(tabulate(
             [
                 [
-                    "Project unique ID", project_config.slug
+                    "Project ID", project_config.public_id
                 ],
                 [
-                    "Default docker container unique ID", project_config.default_container_uid if project_config.default_container_uid else "<None>"
+                    "Project name", project_config.slug
+                ],
+                [
+                    "Default docker container ID", project_config.default_container_public_id if project_config.default_container_public_id else "<None>"
                 ],
                 [
                     "Deploy key path", project_config.deploy_key_path if is_deploy_key_exists else "<None>"
@@ -913,15 +913,19 @@ class ProjectService(AbstractService):
         if project_config is None:
             return None
 
+        if project_config.public_id is None:
+            project = self.__thestage_api_client.get_project(public_id=None, slug=project_config.slug)
+            project_config.public_id = project.public_id
+            self.__config_provider.save_project_config(project_config=project_config)
+
         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,
+                public_id=project_config.public_id,
             )
 
             deploy_key_path = self.__config_provider.save_project_deploy_ssh_key(
                 deploy_ssh_key=deploy_ssh_key,
-                project_slug=project_config.slug,
-                project_id=project_config.id,
+                project_public_id=project_config.public_id,
             )
 
             project_config.deploy_key_path = deploy_key_path
@@ -933,11 +937,13 @@ class ProjectService(AbstractService):
     @error_handler()
     def project_deploy_inference_simulator_model_to_instance(
             self,
-            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:
+            model_public_id: Optional[str] = None,
+            model_slug: 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,
+    ) -> str:
         config = self.__config_provider.get_config()
         project_config: ProjectConfig = self.__get_fixed_project_config()
         if not project_config:
@@ -946,26 +952,30 @@ class ProjectService(AbstractService):
                    {"path": config.runtime.working_directory}))
             raise typer.Exit(1)
 
-        if rented_instance_unique_id and self_hosted_instance_unique_id:
-            typer.echo(__("Error: Cannot provide both rented and self-hosted instance unique IDs."))
+        instance_args_count = sum(v is not None for v in [rented_instance_public_id, rented_instance_slug, self_hosted_instance_public_id, self_hosted_instance_slug])
+        if instance_args_count != 1:
+            typer.echo("Please provide a single instance (rented or self-hosted) identifier - name or ID.")
             raise typer.Exit(1)
 
-        if not rented_instance_unique_id and not self_hosted_instance_unique_id:
-            typer.echo(__("Error: Either a rented instance ID or a self-hosted instance unique ID must be provided."))
+        model_args_count = sum(v is not None for v in [model_public_id, model_slug])
+        if model_args_count != 1:
+            typer.echo("Please provide a single model identifier - name or ID.")
             raise typer.Exit(1)
 
-        typer.echo(__("Creating inference simulator with unique ID: %unique_id_with_timestamp%", {"unique_id_with_timestamp": unique_id_with_timestamp}))
+        typer.echo(f"Creating inference simulator")
         deploy_model_to_instance_response: DeployInferenceModelToInstanceResponse = self.__thestage_api_client.deploy_inference_model_to_instance(
-            unique_id=unique_id,
-            unique_id_with_timestamp=unique_id_with_timestamp,
-            rented_instance_unique_id=rented_instance_unique_id,
-            self_hosted_instance_unique_id=self_hosted_instance_unique_id
+            model_public_id=model_public_id,
+            model_slug=model_slug,
+            rented_instance_public_id=rented_instance_public_id,
+            rented_instance_slug=rented_instance_slug,
+            self_hosted_instance_public_id=self_hosted_instance_public_id,
+            self_hosted_instance_slug=self_hosted_instance_slug,
         )
         if deploy_model_to_instance_response:
             if deploy_model_to_instance_response.message:
                 typer.echo(deploy_model_to_instance_response.message)
             if deploy_model_to_instance_response.is_success:
-                typer.echo("Inference simulator has been scheduled to run successfully.")
+                typer.echo(f"Inference simulator '{deploy_model_to_instance_response.inferenceSimulatorPublicId}' has been scheduled to run successfully.")
             else:
                 typer.echo(__(
                     'Inference simulator failed to run with an error: %server_massage%',
@@ -976,11 +986,14 @@ class ProjectService(AbstractService):
             typer.echo(__("Inference simulator failed to run with an error"))
             raise typer.Exit(1)
 
+        return deploy_model_to_instance_response.inferenceSimulatorPublicId
+
 
     @error_handler()
     def project_deploy_inference_simulator_model_to_sagemaker(
             self,
-            unique_id: Optional[str] = None,
+            model_public_id: Optional[str] = None,
+            model_slug: Optional[str] = None,
             arn: Optional[str] = None,
             instance_type: Optional[str] = None,
             initial_variant_weight: Optional[float] = 1.0,
@@ -1013,7 +1026,8 @@ class ProjectService(AbstractService):
             raise typer.Exit(1)
 
         deploy_model_to_sagemaker_response: DeployInferenceModelToSagemakerResponse = self.__thestage_api_client.deploy_inference_model_to_sagemaker(
-            unique_id=unique_id,
+            model_public_id=model_public_id,
+            model_slug=model_slug,
             arn=arn,
         )
 
@@ -1041,7 +1055,7 @@ class ProjectService(AbstractService):
                 },
             }
 
-            sm_model_name = f"{unique_id}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            sm_model_name = f"{model_slug}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
             create_model_response = sm_client.create_model(
                 ModelName=sm_model_name,
                 ExecutionRoleArn=arn,
@@ -1049,7 +1063,7 @@ class ProjectService(AbstractService):
             )
             typer.echo(f"Model created successfully. Model ARN: {create_model_response['ModelArn']}")
 
-            endpoint_config_name = f"{unique_id}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            endpoint_config_name = f"{model_slug}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
             create_endpoint_config_response = sm_client.create_endpoint_config(
                 EndpointConfigName=endpoint_config_name,
                 ProductionVariants=[
@@ -1065,7 +1079,7 @@ class ProjectService(AbstractService):
             typer.echo(
                 f"Endpoint configuration created successfully. Endpoint Config ARN: {create_endpoint_config_response['EndpointConfigArn']}")
 
-            endpoint_name = f"{unique_id}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            endpoint_name = f"{model_slug}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
             create_endpoint_response = sm_client.create_endpoint(
                 EndpointName=endpoint_name,
                 EndpointConfigName=endpoint_config_name,
@@ -1128,13 +1142,13 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def print_inference_simulator_list(self, project_uid, statuses, row, page):
-        if not project_uid:
+    def print_inference_simulator_list(self, project_public_id, project_slug, statuses, row, page):
+        if not project_public_id and not project_slug:
             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"))
+                typer.echo(__("Provide the project identifier or run this command from within an initialized project directory"))
                 raise typer.Exit(1)
-            project_uid = project_config.slug
+            project_public_id = project_config.public_id
 
         inference_simulator_status_map = self.__thestage_api_client.get_inference_simulator_business_status_map()
 
@@ -1167,7 +1181,8 @@ class ProjectService(AbstractService):
         self.print(
             func_get_data=self.get_project_inference_simulator_list,
             func_special_params={
-                'project_slug': project_uid,
+                'project_public_id': project_public_id,
+                'project_slug': project_slug,
                 'statuses': backend_statuses,
             },
             mapper=ProjectInferenceSimulatorMapper(),
@@ -1180,13 +1195,13 @@ class ProjectService(AbstractService):
 
 
     @error_handler()
-    def print_inference_simulator_model_list(self, project_uid, statuses, row, page):
-        if not project_uid:
+    def print_inference_simulator_model_list(self, project_public_id, project_slug, statuses, row, page):
+        if not project_public_id and not project_slug:
             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"))
+                typer.echo(__("Provide the project identifier or run this command from within an initialized project directory"))
                 raise typer.Exit(1)
-            project_uid = project_config.slug
+            project_public_id = project_config.public_id
 
         inference_simulator_model_status_map = self.__thestage_api_client.get_inference_simulator_model_business_status_map()
 
@@ -1219,30 +1234,32 @@ class ProjectService(AbstractService):
         self.print(
             func_get_data=self.get_project_inference_simulator_model_list,
             func_special_params={
-                'project_slug': project_uid,
+                'project_public_id': project_public_id,
+                'project_slug': project_slug,
                 'statuses': backend_statuses,
             },
             mapper=ProjectInferenceSimulatorModelMapper(),
             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],
+            max_col_width=[100, 100, 100, 100, 25],
             show_index="never",
         )
 
 
-    def print_task_list(self, project_uid, row, page):
-        if not project_uid:
+    def print_task_list(self, project_public_id: Optional[str], project_slug: Optional[str], row, page):
+        if not project_slug and not project_public_id:
             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"))
+                typer.echo(__("Provide the project identifier or run this command from within an initialized project directory"))
                 raise typer.Exit(1)
-            project_uid = project_config.slug
+            project_public_id = project_config.public_id
 
         self.print(
             func_get_data=self.get_project_task_list,
             func_special_params={
-                'project_slug': project_uid,
+                'project_public_id': project_public_id,
+                'project_slug': project_slug,
             },
             mapper=ProjectTaskMapper(),
             headers=list(map(lambda x: x.alias, ProjectTaskEntity.model_fields.values())),
@@ -1251,3 +1268,20 @@ class ProjectService(AbstractService):
             max_col_width=[100, 100, 100, 100, 100, 100, 100, 100],
             show_index="never",
         )
+
+    @error_handler()
+    def get_project_task_list(
+            self,
+            project_public_id: Optional[str],
+            project_slug: Optional[str],
+            row: int = 5,
+            page: int = 1,
+    ) -> PaginatedEntityList[TaskDto]:
+        data: Optional[PaginatedEntityList[TaskDto]] = self.__thestage_api_client.get_task_list_for_project(
+            project_public_id=project_public_id,
+            project_slug=project_slug,
+            page=page,
+            limit=row,
+        )
+
+        return data