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

thestage/project/communication/project_api_client.py

@@ -0,0 +1,46 @@
+from typing import Optional
+
+from thestage.config.business.config_provider import ConfigProvider
+from thestage.services.clients.thestage_api.core.api_client_core import TheStageApiClientCore
+
+from thestage.project.dto.project_response import ProjectDto, ProjectViewResponse
+from thestage.project.dto.get_deploy_ssh_key_request import ProjectGetDeploySshKeyRequest
+from thestage.project.dto.get_deploy_ssh_key_response import ProjectGetDeploySshKeyResponse
+
+
+class ProjectApiClient(TheStageApiClientCore):
+    def __init__(self, config_provider: ConfigProvider):
+        super().__init__(url=config_provider.get_config().main.thestage_api_url)
+        self.__config_provider = config_provider
+
+    def get_project(self, slug: Optional[str], public_id: Optional[str]) -> Optional[ProjectDto]:
+        data = {
+            "projectSlug": slug,
+            "projectPublicId": public_id,
+        }
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v2/project/view',
+            data=data,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        result = ProjectViewResponse.model_validate(response) if response else None
+        project = ProjectDto.model_validate(result.project) if result else None
+        return project if result and result.is_success else None
+
+    def get_project_deploy_ssh_key(self, public_id: str) -> str:
+        request = ProjectGetDeploySshKeyRequest(
+            projectPublicId=public_id,
+        )
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v1/project/get-deploy-ssh-key',
+            data=request.model_dump(),
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        result = ProjectGetDeploySshKeyResponse.model_validate(response) if response else None
+        return result.privateKey if result and result.is_success else None

thestage/project/communication/project_command.py

@@ -0,0 +1,284 @@
+from typing import Optional
+
+import typer
+
+from thestage.task.communication import task_command
+from thestage.cli_command import CliCommand
+from thestage.cli_command_helper import get_command_metadata, check_command_permission, get_command_group_help_panel
+from thestage.controllers.utils_controller import validate_config_and_get_service_factory, get_current_directory
+from thestage.helpers.logger.app_logger import app_logger
+from thestage.i18n.translation import __
+
+app = typer.Typer(no_args_is_help=True, help=__("Manage projects"))
+config_app = typer.Typer(no_args_is_help=True, help=__("Manage project config"))
+app.add_typer(config_app, name="config", rich_help_panel=get_command_group_help_panel())
+app.add_typer(task_command.runner_app, name="")
+
+
+@app.command(name='clone', no_args_is_help=True, help=__("Clone project repository to empty directory"), **get_command_metadata(CliCommand.PROJECT_CLONE))
+def clone(
+        project_public_id: Optional[str] = typer.Option(
+            None,
+            "--project-id",
+            "-pid",
+            help=__("Project ID. ID or name is required"),
+            is_eager=False,
+        ),
+        project_slug: Optional[str] = typer.Option(
+            None,
+            "--project-name",
+            "-pn",
+            help=__("Project name. ID or name is required."),
+            is_eager=False,
+        ),
+        working_directory: Optional[str] = typer.Option(
+            None,
+            "--working-directory",
+            "-wd",
+            help=__("Full path to the working directory: current directory used by default"),
+            is_eager=False,
+        ),
+):
+    command_name = CliCommand.PROJECT_CLONE
+    app_logger.info(f'Running {command_name} from {get_current_directory()}')
+    check_command_permission(command_name)
+
+    if sum(v is not None for v in [project_public_id, project_slug]) != 1:
+        typer.echo("Provide a single identifier for the project - name or ID.")
+        raise typer.Exit(1)
+
+    if not working_directory:
+        project_dir_name = project_public_id if project_slug is None else project_slug
+        working_directory = get_current_directory().joinpath(project_dir_name)
+
+    service_factory = validate_config_and_get_service_factory(working_directory=working_directory)
+    project_service = service_factory.get_project_service()
+
+    project_service.clone_project(
+        project_slug=project_slug,
+        project_public_id=project_public_id,
+    )
+
+    raise typer.Exit(0)
+
+
+@app.command(name='init', no_args_is_help=True, help=__("Initialize project repository with existing files"), **get_command_metadata(CliCommand.PROJECT_INIT))
+def init(
+        project_public_id: Optional[str] = typer.Option(
+            None,
+            "--project-id",
+            "-pid",
+            help=__("Project ID. ID or name is required"),
+            is_eager=False,
+        ),
+        project_slug: Optional[str] = typer.Option(
+            None,
+            "--project-name",
+            "-pn",
+            help=__("Project name. ID or name is required."),
+            is_eager=False,
+        ),
+        working_directory: Optional[str] = typer.Option(
+            None,
+            "--working-directory",
+            "-wd",
+            help=__("Full path to working directory"),
+            is_eager=False,
+        ),
+):
+    command_name = CliCommand.PROJECT_INIT
+    app_logger.info(f'Running {command_name} from {get_current_directory()}')
+    check_command_permission(command_name)
+
+    if sum(v is not None for v in [project_public_id, project_slug]) != 1:
+        typer.echo("Provide a single identifier for the project - name or ID.")
+        raise typer.Exit(1)
+
+    service_factory = validate_config_and_get_service_factory(working_directory=working_directory)
+    project_service = service_factory.get_project_service()
+    project_config = service_factory.get_config_provider().read_project_config()
+
+    if project_config:
+        typer.echo(__("Directory is initialized and already contains working project"))
+        raise typer.Exit(1)
+
+    project_service.init_project(
+        project_slug=project_slug,
+        project_public_id=project_public_id,
+    )
+
+    raise typer.Exit(0)
+
+
+
+@app.command(name='checkout', no_args_is_help=True, help=__("Checkout project repository to a specific reference"), **get_command_metadata(CliCommand.PROJECT_CHECKOUT))
+def checkout_project(
+        task_public_id: Optional[str] = typer.Option(
+            None,
+            "--task-id",
+            "-tid",
+            help="Task ID to checkout",
+            is_eager=False,
+        ),
+        branch_name: Optional[str] = typer.Option(
+            None,
+            "--branch",
+            "-b",
+            help="Branch name to checkout. Use '/' value to checkout to the main branch.",
+            is_eager=False,
+        ),
+        working_directory: Optional[str] = typer.Option(
+            None,
+            "--working-directory",
+            "-wd",
+            help=__("Full path to working directory"),
+            is_eager=False,
+        ),
+):
+    command_name = CliCommand.PROJECT_CHECKOUT
+    app_logger.info(f'Running {command_name} from {get_current_directory()}')
+    check_command_permission(command_name)
+
+    if sum(v is not None for v in [branch_name, task_public_id]) != 1:
+        typer.echo("Provide a single identifier for checkout - task ID or branch name.")
+        raise typer.Exit(1)
+
+    service_factory = validate_config_and_get_service_factory(working_directory=working_directory)
+    project_service = service_factory.get_project_service()
+
+    final_branch_name = branch_name
+    if branch_name == "/":
+        final_branch_name = None
+
+    project_service.checkout_project(
+        task_public_id=task_public_id,
+        branch_name=final_branch_name,
+    )
+
+    raise typer.Exit(0)
+
+
+@app.command(name='pull', help=__("Pulls the changes from the remote project repository. Equivalent to 'git pull'."), **get_command_metadata(CliCommand.PROJECT_PULL))
+def pull_project(
+        working_directory: Optional[str] = typer.Option(
+            None,
+            "--working-directory",
+            "-wd",
+            help=__("Full path to working directory"),
+            is_eager=False,
+        ),
+):
+    command_name = CliCommand.PROJECT_PULL
+    app_logger.info(f'Running {command_name} from {get_current_directory()}')
+    check_command_permission(command_name)
+
+    service_factory = validate_config_and_get_service_factory(working_directory=working_directory)
+    project_service = service_factory.get_project_service()
+
+    project_service.pull_project()
+
+    raise typer.Exit(0)
+
+
+@app.command(name='reset', help=__("Resets the current project branch to remote counterpart. All working tree changes will be lost. Equivalent to 'git fetch && git reset --hard origin/{ref}'."), **get_command_metadata(CliCommand.PROJECT_RESET))
+def reset_project(
+        working_directory: Optional[str] = typer.Option(
+            None,
+            "--working-directory",
+            "-wd",
+            help=__("Full path to working directory"),
+            is_eager=False,
+        ),
+):
+    command_name = CliCommand.PROJECT_RESET
+    app_logger.info(f'Running {command_name} from {get_current_directory()}')
+    check_command_permission(command_name)
+
+    service_factory = validate_config_and_get_service_factory(working_directory=working_directory)
+    project_service = service_factory.get_project_service()
+
+    project_service.reset_project()
+
+    raise typer.Exit(0)
+
+
+@config_app.command(name='set-default-container', no_args_is_help=True, help=__("Set default docker container for a project installation"), **get_command_metadata(CliCommand.PROJECT_CONFIG_SET_DEFAULT_CONTAINER))
+def set_default_container(
+        docker_container_public_id: Optional[str] = typer.Option(
+            None,
+            '--container-id',
+            '-cid',
+            help=__("Docker container ID"),
+            is_eager=False,
+        ),
+        docker_container_slug: Optional[str] = typer.Option(
+            None,
+            '--container-name',
+            '-cn',
+            help=__("Docker container name"),
+            is_eager=False,
+        ),
+        unset_default_container: Optional[bool] = typer.Option(
+            False,
+            "--unset",
+            "-u",
+            help=__("Unsets the default docker container"),
+            is_eager=False,
+        ),
+        working_directory: Optional[str] = typer.Option(
+            None,
+            "--working-directory",
+            "-wd",
+            help=__("Full path to working directory"),
+            is_eager=False,
+        ),
+):
+    command_name = CliCommand.PROJECT_CONFIG_SET_DEFAULT_CONTAINER
+    app_logger.info(f'Running {command_name} from {get_current_directory()}')
+    check_command_permission(command_name)
+
+    container_args_count = sum(v is not None for v in [docker_container_public_id, docker_container_slug])
+    if container_args_count > 1:
+        typer.echo("Provide a single identifier for the container - name or ID.")
+        raise typer.Exit(1)
+
+    service_factory = validate_config_and_get_service_factory(working_directory=working_directory)
+
+    if unset_default_container and container_args_count > 0:
+        typer.echo("Cannot provide container identifier and '--unset' flag simultaneously")
+        raise typer.Exit(1)
+
+    if not unset_default_container and container_args_count != 1:
+        typer.echo("Provide container identifier or use '--unset' flag")
+        raise typer.Exit(1)
+
+    project_service = service_factory.get_project_service()
+
+    project_service.set_default_container(
+        container_public_id=docker_container_public_id,
+        container_slug=docker_container_slug,
+    )
+
+    raise typer.Exit(0)
+
+
+@config_app.command(name='get', no_args_is_help=False, help=__("View config for a local project installation"), **get_command_metadata(CliCommand.PROJECT_CONFIG_GET))
+def get_project_config(
+        working_directory: Optional[str] = typer.Option(
+            None,
+            "--working-directory",
+            "-wd",
+            help=__("Full path to working directory"),
+            is_eager=False,
+        ),
+):
+    command_name = CliCommand.PROJECT_CONFIG_GET
+    app_logger.info(f'Running {command_name} from {get_current_directory()}')
+    check_command_permission(command_name)
+
+    service_factory = validate_config_and_get_service_factory(working_directory=working_directory)
+    project_service = service_factory.get_project_service()
+
+    project_service.print_project_config()
+
+    raise typer.Exit(0)

thestage/{services/project → project}/dto/project_config.py

@@ -10,6 +10,5 @@ class ProjectConfig(BaseModel):
     public_id: str = Field(None, alias='public_id')
     git_repository_url: str = Field(None, alias='git_repository_url')
     deploy_key_path: str = Field(None, alias='deploy_key_path')
-    default_container_uid: Optional[str] = Field(None, alias='default_container_uid') # TODO delete
-    default_container_public_id: Optional[str] = Field(None, alias='default_container_public_id') # TODO use
+    default_container_public_id: Optional[str] = Field(None, alias='default_container_public_id')
     prompt_for_default_container: bool = Field(True, alias='prompt_for_default_container')

thestage/services/clients/thestage_api/core/api_client_core.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 import requests
 
-from thestage.config import THESTAGE_API_URL
+from thestage.config.env_base import THESTAGE_API_URL
 from thestage.exceptions.auth_exception import AuthException
 from thestage import __version__
 from thestage.services.clients.thestage_api.core.http_client_exception import HttpClientException

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

@@ -2,7 +2,7 @@ from typing import Optional
 
 from pydantic import ConfigDict, BaseModel, Field
 
-from thestage.entities.enums.order_direction_type import OrderDirectionType
+from thestage.global_dto.enums.order_direction_type import OrderDirectionType
 
 
 class EntityFilterRequest(BaseModel):

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

@@ -2,7 +2,7 @@ from typing import Optional, List
 
 from pydantic import Field
 
-from thestage.entities.file_item import FileItemEntity
+from thestage.global_dto.file_item import FileItemEntity
 
 
 class SftpFileItemEntity(FileItemEntity):

thestage/services/filesystem_service.py

@@ -5,7 +5,7 @@ from json import JSONDecodeError
 from pathlib import Path
 from typing import Optional, List, Dict, Any
 
-from thestage.entities.file_item import FileItemEntity
+from thestage.global_dto.file_item import FileItemEntity
 from thestage.exceptions.file_system_exception import FileSystemException
 
 
@@ -85,7 +85,7 @@ class FileSystemService:
                 file.write(new_line)
                 file.write('\n')
 
-    # TODO remove this fucking useless shit
+    # TODO remove this
     def check_if_path_exist(self, file: str) -> bool:
         path = self.get_path(file, auto_create=False)
         if path.exists():

thestage/services/service_factory.py

@@ -1,50 +1,71 @@
 from typing import Optional
 
-from thestage.services.config_provider.config_provider import ConfigProvider
-from thestage.services.connect.connect_service import ConnectService
+from thestage.config.business.app_config_service import AppConfigService
+from thestage.config.business.config_provider import ConfigProvider
+from thestage.config.business.validation_service import ValidationService
+from thestage.connect.business.connect_service import ConnectService
+from thestage.connect.business.remote_server_service import RemoteServerService
+from thestage.connect.communication.connect_api_client import ConnectApiClient
+from thestage.docker_container.business.container_service import ContainerService
+from thestage.docker_container.communication.docker_container_api_client import DockerContainerApiClient
+from thestage.git.communication.git_client import GitLocalClient
+from thestage.inference_model.business.inference_model_service import InferenceModelService
+from thestage.inference_model.communication.inference_model_api_client import InferenceModelApiClient
+from thestage.inference_simulator.business.inference_simulator_service import InferenceSimulatorService
+from thestage.inference_simulator.communication.inference_simulator_api_client import InferenceSimulatorApiClient
+from thestage.instance.business.instance_service import InstanceService
+from thestage.instance.communication.instance_api_client import InstanceApiClient
+from thestage.logging.business.logging_service import LoggingService
+from thestage.logging.communication.logging_api_client import LoggingApiClient
+from thestage.project.business.project_service import ProjectService
+from thestage.project.communication.project_api_client import ProjectApiClient
+from thestage.services.clients.thestage_api.core.api_client_core import TheStageApiClientCore
 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
-from thestage.services.container.container_service import ContainerService
-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.validation_service import ValidationService
+from thestage.task.business.task_service import TaskService
+from thestage.task.communication.task_api_client import TaskApiClient
 
 
 class ServiceFactory:
-    __thestage_api_client: Optional[TheStageApiClient] = None
     __git_local_client: Optional[GitLocalClient] = None
     __file_system_service: Optional[FileSystemService] = None
     __config_provider: Optional[ConfigProvider] = None
-
+    __task_api_client: Optional[TaskApiClient] = None
+    __project_api_client: Optional[ProjectApiClient] = None
+    __inference_model_api_client: Optional[InferenceModelApiClient] = None
+    __inference_simulator_api_client: Optional[InferenceSimulatorApiClient] = None
+    __instance_api_client: Optional[InstanceApiClient] = None
+    __docker_container_api_client: Optional[DockerContainerApiClient] = None
+    __connect_api_client: Optional[ConnectApiClient] = None
+    __logging_api_client: Optional[LoggingApiClient] = None
 
     def get_validation_service(self) -> ValidationService:
+        config_provider = self.get_config_provider()
+        core_client = TheStageApiClientCore(url=config_provider.get_config().main.thestage_api_url)
         return ValidationService(
-                thestage_api_client=self.get_thestage_api_client(),
-                config_provider=self.get_config_provider(),
-            )
+            core_client=core_client,
+            config_provider=config_provider,
+        )
 
     def get_instance_service(self) -> InstanceService:
         return InstanceService(
-                thestage_api_client=self.get_thestage_api_client(),
-                remote_server_service=self.get_remote_server_service(),
-                config_provider=self.get_config_provider(),
-            )
+            instance_api_client=self.get_instance_api_client(),
+            remote_server_service=self.get_remote_server_service(),
+            config_provider=self.get_config_provider(),
+        )
 
     def get_container_service(self) -> ContainerService:
         return ContainerService(
-                thestage_api_client=self.get_thestage_api_client(),
-                remote_server_service=self.get_remote_server_service(),
-                file_system_service=self.get_file_system_service(),
-                config_provider=self.get_config_provider(),
-            )
+            docker_container_api_client=self.get_docker_container_api_client(),
+            remote_server_service=self.get_remote_server_service(),
+            file_system_service=self.get_file_system_service(),
+            config_provider=self.get_config_provider(),
+            connect_api_client=self.get_connect_api_client(),
+        )
 
     def get_connect_service(self) -> ConnectService:
         return ConnectService(
-            thestage_api_client=self.get_thestage_api_client(),
+            instance_api_client=self.get_instance_api_client(),
+            connect_api_client=self.get_connect_api_client(),
             instance_service=self.get_instance_service(),
             container_service=self.get_container_service(),
             logging_service=self.get_logging_service(),
@@ -52,23 +73,100 @@ class ServiceFactory:
 
     def get_project_service(self) -> ProjectService:
         return ProjectService(
-            thestage_api_client=self.get_thestage_api_client(),
+            task_api_client=self.get_task_api_client(),
+            docker_container_api_client=self.get_docker_container_api_client(),
+            project_api_client=self.get_project_api_client(),
             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_task_service(self) -> TaskService:
+        return TaskService(
+            docker_container_api_client=self.get_docker_container_api_client(),
+            project_service=self.get_project_service(),
+            task_api_client=self.get_task_api_client(),
+            config_provider=self.get_config_provider(),
+            git_local_client=self.get_git_local_client(),
+            file_system_service=self.get_file_system_service(),
+        )
+
+    def get_inference_simulator_service(self) -> InferenceSimulatorService:
+        return InferenceSimulatorService(
+            inference_simulator_api_client=self.get_inference_simulator_api_client(),
+            inference_model_api_client=self.get_inference_model_api_client(),
+            config_provider=self.get_config_provider(),
+            git_local_client=self.get_git_local_client(),
+            project_service=self.get_project_service(),
+        )
+
+    def get_inference_model_service(self) -> InferenceModelService:
+        return InferenceModelService(
+            inference_model_api_client=self.get_inference_model_api_client(),
+            config_provider=self.get_config_provider(),
+            project_service=self.get_project_service(),
+        )
+
     def get_remote_server_service(self) -> RemoteServerService:
         return RemoteServerService(
             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(config_provider=self.get_config_provider())
-        return self.__thestage_api_client
+    def get_app_config_service(self) -> AppConfigService:
+        return AppConfigService(
+            config_provider=self.get_config_provider(),
+            validation_service=self.get_validation_service(),
+        )
+
+    def get_logging_service(self) -> LoggingService:
+        return LoggingService(
+            logging_api_client=self.get_logging_api_client(),
+            docker_container_api_client=self.get_docker_container_api_client(),
+            task_api_client=self.get_task_api_client(),
+            inference_simulator_api_client=self.get_inference_simulator_api_client(),
+        )
+
+    def get_task_api_client(self) -> TaskApiClient:
+        if not self.__task_api_client:
+            self.__task_api_client = TaskApiClient(config_provider=self.get_config_provider())
+        return self.__task_api_client
+
+    def get_project_api_client(self) -> ProjectApiClient:
+        if not self.__project_api_client:
+            self.__project_api_client = ProjectApiClient(config_provider=self.get_config_provider())
+        return self.__project_api_client
+
+    def get_inference_model_api_client(self) -> InferenceModelApiClient:
+        if not self.__inference_model_api_client:
+            self.__inference_model_api_client = InferenceModelApiClient(config_provider=self.get_config_provider())
+        return self.__inference_model_api_client
+
+    def get_inference_simulator_api_client(self) -> InferenceSimulatorApiClient:
+        if not self.__inference_simulator_api_client:
+            self.__inference_simulator_api_client = InferenceSimulatorApiClient(config_provider=self.get_config_provider())
+        return self.__inference_simulator_api_client
+
+    def get_instance_api_client(self) -> InstanceApiClient:
+        if not self.__instance_api_client:
+            self.__instance_api_client = InstanceApiClient(config_provider=self.get_config_provider())
+        return self.__instance_api_client
+
+    def get_docker_container_api_client(self) -> DockerContainerApiClient:
+        if not self.__docker_container_api_client:
+            self.__docker_container_api_client = DockerContainerApiClient(config_provider=self.get_config_provider())
+        return self.__docker_container_api_client
+
+    def get_connect_api_client(self) -> ConnectApiClient:
+        if not self.__connect_api_client:
+            self.__connect_api_client = ConnectApiClient(config_provider=self.get_config_provider())
+        return self.__connect_api_client
+
+    def get_logging_api_client(self) -> LoggingApiClient:
+        if not self.__logging_api_client:
+            self.__logging_api_client = LoggingApiClient(config_provider=self.get_config_provider())
+        return self.__logging_api_client
 
     def get_git_local_client(self):
         if not self.__git_local_client:
@@ -80,18 +178,7 @@ class ServiceFactory:
             self.__file_system_service = FileSystemService()
         return self.__file_system_service
 
-    def get_app_config_service(self) -> AppConfigService:
-        return AppConfigService(
-            config_provider=self.get_config_provider(),
-            validation_service=self.get_validation_service(),
-        )
-
-    def get_logging_service(self) -> LoggingService:
-        return LoggingService(
-            thestage_api_client=self.get_thestage_api_client(),
-        )
-
     def get_config_provider(self) -> ConfigProvider:
         if not self.__config_provider:
             self.__config_provider = ConfigProvider(self.get_file_system_service())
-        return self.__config_provider
+        return self.__config_provider

thestage/{services/project/mapper/project_task_mapper.py → task/business/mapper/task_mapper.py}

@@ -1,17 +1,17 @@
 from typing import Optional
 
-from thestage.entities.project_task import ProjectTaskEntity
+from thestage.task.dto.task_entity import TaskEntity
 from thestage.services.abstract_mapper import AbstractMapper
-from thestage.services.task.dto.task_dto import TaskDto
+from thestage.task.dto.task import Task
 
 
-class ProjectTaskMapper(AbstractMapper):
+class TaskMapper(AbstractMapper):
 
-    def build_entity(self, item: TaskDto) -> Optional[ProjectTaskEntity]:
+    def build_entity(self, item: Task) -> Optional[TaskEntity]:
         if not item:
             return None
 
-        return ProjectTaskEntity(
+        return TaskEntity(
             public_id=item.public_id or '',
             title=item.title or '',
             status=item.frontend_status.status_translation or '',