thestage 0.5.37__py3-none-any.whl → 0.5.39__py3-none-any.whl

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

@@ -0,0 +1,25 @@
+from typing import Optional, List, Tuple
+
+from thestage.services.clients.thestage_api.core.api_client_abstract import TheStageApiClientAbstract
+from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
+from thestage import __version__
+
+
+class TheStageApiClientCore(TheStageApiClientAbstract):
+
+    def __init__(self, timeout: int = 90, url: Optional[str] = None):
+        super(TheStageApiClientCore, self).__init__(timeout=timeout, url=url)
+
+    def validate_token(self, token: str) -> bool:
+        data = {
+            "userApiToken": token,
+            "cliVersion": __version__,
+        }
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v1/validate-token',
+            data=data,
+        )
+        result = TheStageBaseResponse.model_validate(response) if response else None
+        return result.is_success if result else False

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

@@ -0,0 +1,12 @@
+from thestage.exceptions.base_exception import BaseAbstractException
+
+
+class HttpClientException(BaseAbstractException):
+    _status_code: int = 0
+
+    def __init__(self, message: str, status_code: int, ):
+        super(HttpClientException, self).__init__(message=message)
+        self._status_code = status_code
+
+    def get_status_code(self) -> int:
+        return self._status_code

thestage/services/clients/thestage_api/dtos/inference_controller/deploy_inference_model_to_instance_request.py

@@ -0,0 +1,14 @@
+from typing import Optional, List
+
+from pydantic import Field, ConfigDict, BaseModel
+
+from thestage.services.clients.thestage_api.dtos.entity_filter_request import EntityFilterRequest
+
+
+class DeployInferenceModelToInstanceRequest(BaseModel):
+    model_config = ConfigDict(use_enum_values=True)
+
+    modelSlug: Optional[str] = Field(None, alias='modelSlug')
+    instanceRentedSlug: Optional[str] = Field(None, alias='instanceRentedSlug')
+    selfhostedInstanceSlug: Optional[str] = Field(None, alias='selfhostedInstanceSlug')
+    inferenceSimulatorSlug: Optional[str] = Field(None, alias='inferenceSimulatorSlug')

thestage/services/clients/thestage_api/dtos/inference_controller/deploy_inference_model_to_instance_response.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from pydantic import Field, ConfigDict
+
+from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
+from thestage.services.project.dto.inference_simulator_model_dto import InferenceSimulatorModelDto
+
+
+class DeployInferenceModelToInstanceResponse(TheStageBaseResponse):
+    model_config = ConfigDict(use_enum_values=True)
+    inferenceSimulatorModel: Optional[InferenceSimulatorModelDto] = Field(None, alias='inferenceSimulatorModel')
+
+

thestage/services/clients/thestage_api/dtos/inference_controller/deploy_inference_model_to_sagemaker_request.py

@@ -0,0 +1,12 @@
+from typing import Optional, List
+
+from pydantic import Field, ConfigDict, BaseModel
+
+from thestage.services.clients.thestage_api.dtos.entity_filter_request import EntityFilterRequest
+
+
+class DeployInferenceModelToSagemakerRequest(BaseModel):
+    model_config = ConfigDict(use_enum_values=True)
+
+    modelSlug: Optional[str] = Field(None, alias='modelSlug')
+    arn: Optional[str] = Field(None, alias='arn')

thestage/services/clients/thestage_api/dtos/inference_controller/deploy_inference_model_to_sagemaker_response.py

@@ -0,0 +1,12 @@
+from pydantic import Field, ConfigDict
+
+from thestage.services.clients.thestage_api.dtos.base_response import TheStageBaseResponse
+
+
+class DeployInferenceModelToSagemakerResponse(TheStageBaseResponse):
+    model_config = ConfigDict(use_enum_values=True)
+    modelId: str = Field(None, alias='modelId')
+    ecrImageUrl: str = Field(None, alias='ecrImageUrl')
+    s3ArtifactsUrl: str = Field(None, alias='s3ArtifactsUrl')
+
+

thestage/services/clients/thestage_api/dtos/logging_controller/log_polling_request.py

@@ -9,5 +9,5 @@ class LogPollingRequest(BaseModel):
     taskId: Optional[int] = Field(None, alias='taskId')
     inferenceSimulatorId: Optional[int] = Field(None, alias='inferenceSimulatorId')
     lastLogId: Optional[str] = Field(None, alias='lastLogId')
-    dockerContainerId: Optional[str] = Field(None, alias='dockerContainerId')
+    dockerContainerId: Optional[int] = Field(None, alias='dockerContainerId')
     lastLogTimestamp: Optional[str] = Field(None, alias='lastLogTimestamp')

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

@@ -1,7 +1,8 @@
 from typing import Optional, List
 
-from pydantic import BaseModel, Field
-from thestage_core.entities.file_item import FileItemEntity
+from pydantic import Field
+
+from thestage.entities.file_item import FileItemEntity
 
 
 class SftpFileItemEntity(FileItemEntity):

thestage/services/config_provider/config_provider.py

@@ -1,30 +1,56 @@
+import typer
+
+import json
 import os
+from json import JSONDecodeError
 from pathlib import Path
-from typing import Optional, Dict
+from typing import Optional, Dict, Any
 
-import typer
-from thestage_core.entities.config_entity import ConfigEntity
-from thestage_core.services.config_provider.config_provider import ConfigProviderCore
-
-from thestage.config import THESTAGE_AUTH_TOKEN, THESTAGE_API_URL
+from thestage.exceptions.file_system_exception import FileSystemException
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.helpers.ssh_util import parse_private_key
 from thestage.services.connect.dto.remote_server_config import RemoteServerConfig
+from thestage.services.filesystem_service import FileSystemServiceCore
 from thestage.services.project.dto.project_config import ProjectConfig
+from thestage.config import THESTAGE_CONFIG_DIR, THESTAGE_CONFIG_FILE, THESTAGE_AUTH_TOKEN, THESTAGE_API_URL
+
+class ConfigProvider():
+    # path to current physical subject we work with (project / etc) - might be passed explicitly
+    _local_path: Optional[Path] = None
+    _local_config_path: Optional[Path] = None
+    _global_config_path: Optional[Path] = None
+    _global_config_file: Optional[Path] = None
+    _file_system_service = FileSystemServiceCore
 
 
-class ConfigProvider(ConfigProviderCore):
     def __init__(
             self,
-            local_path: str,
+            local_path: Optional[str] = None,
     ):
-        super(ConfigProvider, self).__init__(
-            local_path=local_path,
+        self._file_system_service = FileSystemServiceCore()
+        if local_path:
+            self._local_path = self._file_system_service.get_path(directory=local_path, auto_create=False)
+
+        config_folder_name = self._file_system_service.get_path(f"{THESTAGE_CONFIG_DIR}", False)
+        self._local_config_path = self._local_path.joinpath(config_folder_name)
+
+        home_dir = self._file_system_service.get_home_path()
+        self._global_config_path = home_dir.joinpath(config_folder_name)
+
+        if self._global_config_path:
+            if not self._global_config_path.exists():
+                self._file_system_service.create_if_not_exists_dir(self._global_config_path)
+
+        self._global_config_file = self._global_config_path.joinpath(
+            self._file_system_service.get_path(f"{THESTAGE_CONFIG_FILE}", False)
         )
+        if not self._global_config_file.exists():
+            self._file_system_service.create_if_not_exists_file(self._global_config_file)
+
 
-    def get_full_config(self, check_daemon: bool = False,) -> ConfigEntity:
+    def get_full_config(self) -> ConfigEntity:
         config_values = {}
 
-        # read env data
         config_from_env = {}
         config_from_env['main'] = {}
         if THESTAGE_AUTH_TOKEN:
@@ -35,8 +61,7 @@ class ConfigProvider(ConfigProviderCore):
         if config_from_env:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_env)
 
-        # read global config data
-        config_from_file = self._read_config_file(self._global_config_file)
+        config_from_file = self.__read_config_file(self._global_config_file)
         if config_from_file:
             self.__update_config_values_dict(values_to_update=config_values, new_values=config_from_file)
 
@@ -47,27 +72,25 @@ class ConfigProvider(ConfigProviderCore):
         if self._global_config_path and not config.runtime.config_global_path:
             config.runtime.config_global_path = str(self._global_config_path)
 
-        if check_daemon:
-            self.check_for_daemon(config=config)
-
         return config
 
+
     def save_project_config(self, project_config: ProjectConfig):
-        self.__create_empty_project_config_if_missing()
-        # self.read_project_config()
-        project_config_path = self.__get_project_config_path(with_file=True)
-        self._save_config_file(data=project_config.model_dump(), file_path=project_config_path)
+        project_data_dirpath = self.__get_project_config_path()
+        if not project_data_dirpath.exists():
+            self._file_system_service.create_if_not_exists_dir(project_data_dirpath)
+
+        project_data_filepath = self.__get_project_config_path(with_file=True)
+        if not project_data_filepath.exists():
+            self._file_system_service.create_if_not_exists_file(project_data_filepath)
 
-    def save_remote_server_config(self, remote_server_config: RemoteServerConfig):
-        self.__create_empty_project_config_if_missing()
-        # self.read_project_config()
         project_config_path = self.__get_project_config_path(with_file=True)
-        self._save_config_file(data=remote_server_config.model_dump(), file_path=project_config_path)
+        self.__save_config_file(data=project_config.model_dump(), file_path=project_config_path)
 
 
     def save_project_deploy_ssh_key(self, deploy_ssh_key: str, project_slug: str, project_id: int) -> str:
         deploy_key_dirpath = self._global_config_path.joinpath('project_deploy_keys')
-        self._file_system_service.create_if_not_exists(deploy_key_dirpath)
+        self._file_system_service.create_if_not_exists_dir(deploy_key_dirpath)
 
         deploy_key_filepath = deploy_key_dirpath.joinpath(f'project_deploy_key_{project_id}_{project_slug}')
         self._file_system_service.create_if_not_exists_file(deploy_key_filepath)
@@ -79,30 +102,20 @@ class ConfigProvider(ConfigProviderCore):
 
         return str(deploy_key_filepath)
 
+
     def read_project_config(self) -> Optional[ProjectConfig]:
         project_data_dirpath = self.__get_project_config_path()
         if not project_data_dirpath.exists():
             return None
-            # self._file_system_service.create_if_not_exists(project_data_dirpath)
 
         project_data_filepath = self.__get_project_config_path(with_file=True)
         if not project_data_filepath.exists():
             return None
 
-        config_data = self._read_config_file(project_data_filepath) if project_data_filepath and project_data_filepath.exists() else {}
+        config_data = self.__read_config_file(project_data_filepath) if project_data_filepath and project_data_filepath.exists() else {}
         return ProjectConfig.model_validate(config_data)
 
 
-    def __create_empty_project_config_if_missing(self):
-        project_data_dirpath = self.__get_project_config_path()
-        if not project_data_dirpath.exists():
-            self._file_system_service.create_if_not_exists(project_data_dirpath)
-
-        project_data_filepath = self.__get_project_config_path(with_file=True)
-        if not project_data_filepath.exists():
-            self._file_system_service.create_if_not_exists_file(project_data_filepath)
-
-
     def __get_project_config_path(self, with_file: bool = False) -> Path:
         if with_file:
             return self._local_config_path.joinpath('project.json')
@@ -124,7 +137,7 @@ class ConfigProvider(ConfigProviderCore):
                 typer.echo("Could not identify provided private key (expected RSA, ECDSA, ED25519)")
                 raise typer.Exit(1)
 
-        config = self.read_remote_server_config()
+        config = self.__read_remote_server_config()
         remote_server_config_filepath = self.__get_remote_server_config_path()
         if config:
             if not config.ip_address_to_ssh_key_map:
@@ -142,21 +155,22 @@ class ConfigProvider(ConfigProviderCore):
             self._file_system_service.create_if_not_exists_file(remote_server_config_filepath)
             config = RemoteServerConfig(ip_address_to_ssh_key_map={ip_address: str(ssh_key_path)})
 
-        self._save_config_file(data=config.model_dump(), file_path=remote_server_config_filepath)
+        self.__save_config_file(data=config.model_dump(), file_path=remote_server_config_filepath)
 
         return str(remote_server_config_filepath)
 
 
-    def read_remote_server_config(self) -> Optional[RemoteServerConfig]:
+    def __read_remote_server_config(self) -> Optional[RemoteServerConfig]:
         config_filepath = self.__get_remote_server_config_path()
         if not config_filepath.is_file():
             return None
 
-        config_data = self._read_config_file(config_filepath) if config_filepath and config_filepath.exists() else {}
+        config_data = self.__read_config_file(config_filepath) if config_filepath and config_filepath.exists() else {}
         return RemoteServerConfig.model_validate(config_data)
 
+
     def get_valid_private_key_path_by_ip_address(self, ip_address: str) -> Optional[str]:
-        remote_server_config = self.read_remote_server_config()
+        remote_server_config = self.__read_remote_server_config()
         if remote_server_config and remote_server_config.ip_address_to_ssh_key_map:
             private_key_path = remote_server_config.ip_address_to_ssh_key_map.get(ip_address)
             if private_key_path and Path(private_key_path).is_file():
@@ -165,10 +179,50 @@ class ConfigProvider(ConfigProviderCore):
                 self.update_remote_server_config_entry(ip_address, None)
         return None
 
+
     @staticmethod
     def __update_config_values_dict(values_to_update: Dict, new_values: Dict):
         if 'main' in new_values:
             if 'main' in values_to_update:
                 values_to_update['main'].update(new_values['main'])
             else:
-                values_to_update['main'] = new_values['main']
+                values_to_update['main'] = new_values['main']
+
+
+    def __read_config_file(self, path: Path) -> Dict[str, Any]:
+        result = {}
+        try:
+            if path and path.exists():
+                with path.open("r") as file:
+                    try:
+                        if os.stat(path).st_size != 0:
+                            result = json.load(file)
+                    except JSONDecodeError:
+                        pass
+        except OSError:
+            raise FileSystemException(f"Could not open config file: {path}")
+        return result
+
+
+    @staticmethod
+    def __save_config_file(data: Dict, file_path: Path):
+        with open(file_path, 'w') as configfile:
+            json.dump(data, configfile, indent=1)
+
+
+    def save_config(self, config: ConfigEntity):
+        data: Dict[str, Any] = self.__read_config_file(self._global_config_file)
+        data.update(config.model_dump(exclude_none=True, by_alias=True, exclude={'runtime', 'RUNTIME', 'daemon', 'DAEMON'}))
+        self.__save_config_file(data=data, file_path=self._global_config_file)
+
+
+    def clear_config(self, ):
+        if self._global_config_path and self._global_config_path.exists():
+            self._file_system_service.remove_folder(str(self._global_config_path))
+
+        os.unsetenv('THESTAGE_CONFIG_DIR')
+        os.unsetenv('THESTAGE_CONFIG_FILE')
+        os.unsetenv('THESTAGE_CLI_ENV')
+        os.unsetenv('THESTAGE_API_URL')
+        os.unsetenv('THESTAGE_LOG_FILE')
+        os.unsetenv('THESTAGE_AUTH_TOKEN')

thestage/services/connect/connect_service.py

@@ -1,8 +1,8 @@
 from typing import Optional
 import typer
-from thestage_core.exceptions.http_error_exception import HttpClientException
 
 from thestage.i18n.translation import __
+from thestage.services.clients.thestage_api.core.http_client_exception import HttpClientException
 from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
 from thestage.services.clients.thestage_api.dtos.enums.selfhosted_status import SelfhostedBusinessStatus
 from thestage.services.clients.thestage_api.dtos.enums.instance_rented_status import InstanceRentedBusinessStatus

thestage/services/container/container_service.py

@@ -1,22 +1,16 @@
-import uuid
 from pathlib import Path
 from typing import List, Tuple, Optional, Dict
 
 import typer
-from thestage_core.entities.config_entity import ConfigEntity
-from thestage_core.entities.file_item import FileItemEntity
-from thestage_core.services.filesystem_service import FileSystemServiceCore
-
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.entities.container import DockerContainerEntity
-from thestage.helpers.logger.app_logger import app_logger
 from thestage.services.clients.thestage_api.dtos.container_param_request import DockerContainerActionRequestDto
 from thestage.services.clients.thestage_api.dtos.enums.container_pending_action import DockerContainerAction
 from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
 from thestage.entities.enums.shell_type import ShellType
 from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
-from thestage.services.clients.thestage_api.dtos.project_response import ProjectDto
-from thestage.services.clients.thestage_api.dtos.sftp_path_helper import SftpFileItemEntity
 from thestage.services.container.mapper.container_mapper import ContainerMapper
+from thestage.services.filesystem_service import FileSystemServiceCore
 from thestage.services.remote_server_service import RemoteServerService
 from thestage.i18n.translation import __
 from thestage.services.abstract_service import AbstractService

thestage/services/core_files/config_entity.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+# saved to file
+class MainConfigEntity(BaseModel):
+    thestage_auth_token: Optional[str] = Field(None, alias='thestage_auth_token')
+    thestage_api_url: Optional[str] = Field(None, alias='thestage_api_url')
+
+
+class DaemonConfigEntity(BaseModel):
+    daemon_token: Optional[str] = Field(None, alias='daemon_token')
+    backend_api_url: Optional[str] = Field(None, alias='backend_api_url')
+
+# not saved to file
+class RuntimeConfigEntity(BaseModel):
+    working_directory: Optional[str] = Field(None, alias='working_directory')
+    config_global_path: Optional[str] = Field(None, alias='config_global_path')
+
+
+class ConfigEntity(BaseModel):
+    main: MainConfigEntity = Field(default_factory=MainConfigEntity, alias='main')
+    runtime: RuntimeConfigEntity = Field(default_factory=RuntimeConfigEntity, alias="runtime") # TODO merge with main
+    daemon: DaemonConfigEntity = Field(default_factory=DaemonConfigEntity, alias="daemon") # TODO this should not be in core package
+    start_on_daemon: bool = Field(False, alias='start_on_daemon') # TODO this should not be in core package

thestage/services/filesystem_service.py

@@ -0,0 +1,115 @@
+import os
+import shutil
+from pathlib import Path
+from typing import Optional, List
+
+from thestage.entities.file_item import FileItemEntity
+from thestage.exceptions.file_system_exception import FileSystemException
+
+
+class FileSystemServiceCore:
+
+    def get_ssh_path(self) -> Optional[Path]:
+        home_path = self.get_home_path()
+        ssh_path = home_path.joinpath('.ssh')
+        if not ssh_path.exists():
+            raise FileSystemException(f"Path does not exist: {ssh_path}")
+        return ssh_path
+
+    def get_home_path(self) -> Optional[Path]:
+        try:
+            return Path.home()
+        except RuntimeError | OSError as ex1:
+            raise FileSystemException("Error getting user home path") from ex1
+
+    def create_if_not_exists_dir(self, path: Path) -> Path:
+        if not path.exists():
+            try:
+                path.mkdir(exist_ok=True, parents=True)
+            except FileNotFoundError as ex1:
+                raise FileSystemException(message=f"FileNotFoundError (dir): {path}") from ex1
+            except OSError as ex2:
+                raise FileSystemException(message=f"Could not create directory: {path}") from ex2
+        return path
+
+    def create_if_not_exists_file(self, path: Path) -> Path:
+        if not path.exists():
+            try:
+                path.touch(exist_ok=True)
+            except FileNotFoundError as ex1:
+                raise FileSystemException(message=f"FileNotFoundError (file): {path}") from ex1
+            except OSError as ex2:
+                raise FileSystemException(message=f"Could not create file: {path}") from ex2
+        return path
+
+    def get_path(self, directory: str, auto_create: bool = True) -> Path:
+        path = Path(directory)
+        if auto_create:
+            self.create_if_not_exists_dir(path)
+        return path
+
+    def is_folder_empty(self, folder: str, auto_create: bool) -> bool:
+        path = self.get_path(folder, auto_create)
+        if not path.exists():
+            return True
+        if not path.is_dir():
+            raise FileSystemException(message=f"Expected directory but found a file: {path}")
+        objects = os.listdir(path)
+        if len(objects) == 0:
+            return True
+        else:
+            return False
+
+    def is_folder_exists(self, folder: str, auto_create: bool = True) -> bool:
+        path = self.get_path(folder, auto_create=auto_create)
+        if path.exists():
+            return True
+        else:
+            return False
+
+    def find_line_in_text_file(self, file: str, find: str) -> bool:
+        path = self.get_path(file, auto_create=False)
+        if path and path.exists():
+            with open(path, 'r') as file:
+                for line in file.readlines():
+                    if (find + "\n") == line:
+                        return True
+        return False
+
+    def add_line_to_text_file(self, file: str, new_line: str):
+        path = self.get_path(file, auto_create=False)
+        if path and path.exists():
+            with open(path, 'a') as file:
+                file.write(new_line)
+                file.write('\n')
+
+    def check_if_path_exist(self, file: str) -> bool:
+        path = self.get_path(file, auto_create=False)
+        if path.exists():
+            return True
+        else:
+            return False
+
+    def get_path_items(self, folder: str) -> List[FileItemEntity]:
+        path = self.get_path(folder, auto_create=False)
+        path_items = []
+        if not path.exists():
+            return path_items
+
+        parent = FileItemEntity.build_from_path(path=path)
+        path_items.append(parent)
+        if path.is_dir():
+            objects = os.listdir(path)
+            if objects:
+                for item in objects:
+                    elem = path.joinpath(item)
+                    if elem.is_dir():
+                        parent.children.extend(self.get_path_items(folder=str(elem)))
+                    else:
+                        parent.children.append(FileItemEntity.build_from_path(path=elem))
+        return path_items
+
+    def remove_folder(self, path: str):
+        real_path = self.get_path(directory=path, auto_create=False)
+        if real_path and real_path.exists():
+            shutil.rmtree(real_path)

thestage/services/instance/instance_service.py

@@ -2,8 +2,7 @@ from pathlib import Path
 from typing import List, Optional, Dict
 
 import typer
-from thestage_core.entities.config_entity import ConfigEntity
-
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.i18n.translation import __
 from thestage.services.clients.thestage_api.dtos.enums.selfhosted_status import SelfhostedBusinessStatus
 from thestage.services.clients.thestage_api.dtos.enums.instance_rented_status import InstanceRentedBusinessStatus