xmipp3-installer 1.0.0__py3-none-any.whl

xmipp3_installer/installer/modes/mode_clean/mode_clean_bin_executor.py

@@ -0,0 +1,94 @@
+import glob
+import os
+import pathlib
+from typing import List
+
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer import constants
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.modes.mode_clean import mode_clean_executor
+
+class ModeCleanBinExecutor(mode_clean_executor.ModeCleanExecutor):
+	def _get_paths_to_delete(self) -> List[str]:
+		"""
+		### Returns a list of all the paths to be deleted.
+
+		#### Returns:
+		- (list(str)): List containing all the paths to delete.
+		"""
+		dblite_files = glob.glob(
+			"**/*.dblite",
+			recursive=True
+		)
+		return [
+			*dblite_files,
+			*ModeCleanBinExecutor.__get_compilation_files(),
+			*ModeCleanBinExecutor.__get_empty_dirs(),
+			*ModeCleanBinExecutor.__get_pycache_dirs(),
+			paths.BUILD_PATH
+		]
+
+	def _get_confirmation_keyword(self) -> str:
+		"""
+		### Returns the keyword needed to be introduced by the user to confirm an operation.
+
+		#### Returns:
+		- (str): Confirmation keyword.
+		"""
+		return "y"
+	
+	def _get_confirmation_message(self) -> str:
+		"""
+		### Returns message to be printed when asking for user confirmation.
+
+		#### Returns:
+		- (str): Confirmation message.
+		"""
+		return '\n'.join([
+			logger.yellow(f"WARNING: This will DELETE from {paths.SOURCES_PATH} all *.so, *.os and *.o files. Also the *.pyc and *.dblite files"),
+			logger.yellow(f"If you are sure you want to do this, type '{self._get_confirmation_keyword()}' (case sensitive):")
+		])
+	
+	@staticmethod
+	def __get_compilation_files():
+		"""
+		### Returns a list of all the compilation-related files.
+
+		#### Returns:
+		- (list(str)): List containing all the paths to compilation-related files.
+		"""
+		compilation_files = []
+		for root, _, files in os.walk(paths.SOURCES_PATH):
+			for pattern in ['*.so', '*.os', '*.o']:
+				for filename in glob.fnmatch.filter(files, pattern):
+					compilation_files.append(os.path.join(root, filename))
+		return compilation_files
+
+	@staticmethod
+	def __get_empty_dirs() -> List[str]:
+		"""
+		### Returns a list with all the empty directories inside the programs folder.
+
+		#### Returns:
+		- (list(str)): List containing the paths to all the empty directories.
+		"""
+		empty_dirs = [] 
+		for root, dirs, files in os.walk(os.path.join(
+			paths.SOURCES_PATH, constants.XMIPP, "applications", "programs"
+		)): 
+			if not len(dirs) and not len(files): 
+				empty_dirs.append(root) 
+		return empty_dirs
+
+	@staticmethod
+	def __get_pycache_dirs() -> List[str]:
+		"""
+		### Returns a list of all the __pycache__ directories.
+
+		#### Returns:
+		- (list(str)): List containing all the paths to __pycache__ directories.
+		"""
+		return [
+			str(path) for path in pathlib.Path().rglob('__pycache__')
+		]
+	

xmipp3_installer/installer/modes/mode_clean/mode_clean_executor.py

@@ -0,0 +1,45 @@
+from abc import abstractmethod
+from typing import Tuple, List
+
+from xmipp3_installer.application import user_interactions
+from xmipp3_installer.application.logger import errors
+from xmipp3_installer.application.logger import predefined_messages
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer.modes import mode_executor
+from xmipp3_installer.shared import file_operations
+
+class ModeCleanExecutor(mode_executor.ModeExecutor):
+	def run(self) -> Tuple[int, str]:
+		"""
+		### Deletes the compiled binaries.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the error status and an error message if there was an error. 
+		"""
+		if not self.__get_confirmation():
+			return errors.INTERRUPTED_ERROR, ""
+		file_operations.delete_paths(self._get_paths_to_delete())
+		logger(predefined_messages.get_done_message())
+		return 0, ""
+	
+	def __get_confirmation(self) -> bool:
+		"""
+		### Asks the user for confirmation.
+
+		#### Returns:
+		- (bool): True if the user confirms, False otherwise.
+		"""
+		logger(self._get_confirmation_message())
+		return user_interactions.get_user_confirmation(self._get_confirmation_keyword())
+	
+	@abstractmethod
+	def _get_paths_to_delete(self) -> List[str]:
+		"""Get paths to delete method to be implemented by the inheriting classes."""
+	
+	@abstractmethod
+	def _get_confirmation_message(self) -> str:
+		"""Get confirmation message method to be implemented by the inheriting classes."""
+	
+	@abstractmethod
+	def _get_confirmation_keyword(self) -> str:
+		"""Get confirmation keyword method to be implemented by the inheriting classes."""

xmipp3_installer/installer/modes/mode_cmake/__init__.py

@@ -0,0 +1 @@
+"""### Contains the executors for the CMake modes."""

xmipp3_installer/installer/modes/mode_cmake/mode_cmake_executor.py

@@ -0,0 +1,55 @@
+import shutil
+from abc import abstractmethod
+from typing import Dict, Tuple, Optional
+
+from xmipp3_installer.application.cli.arguments import params
+from xmipp3_installer.application.logger import errors
+from xmipp3_installer.installer.modes import mode_executor
+from xmipp3_installer.repository.config_vars import variables
+
+class ModeCMakeExecutor(mode_executor.ModeExecutor):
+	def __init__(self, context: Dict):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- context (dict): Dictionary containing the installation context variables.
+		"""
+		super().__init__(context)
+		self.substitute = not context[params.PARAM_KEEP_OUTPUT]
+		self.cmake = context[variables.CMAKE]
+		self.build_type = context[variables.BUILD_TYPE]
+
+	def run(self) -> Tuple[int, str]:
+		"""
+		### Runs the CMake config with the appropiate params.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the error status and an error message if there was an error. 
+		"""
+		cmake = self.__get_cmake_executable()
+		if not cmake:
+			return errors.CMAKE_ERROR, "CMake installation not found."
+		return self._run_cmake_mode(cmake)
+	
+	def _set_executor_config(self):
+		"""
+		### Sets the specific executor params for this mode.
+		"""
+		super()._set_executor_config()
+		self.logs_to_file = True
+		self.prints_with_substitution = True
+	
+	def __get_cmake_executable(self) -> Optional[str]:
+		"""
+		### Returns the path to the CMake executable to be used.
+
+		#### Returns:
+		- (str | None): Path to the CMake executable. None if it was not found.
+		"""
+		return self.cmake or shutil.which("cmake")
+	
+	@abstractmethod
+	def _run_cmake_mode(self, cmake: str) -> Tuple[int, str]:
+		"""Run CMake mode method to be implemented by inheriting classes."""
+	

xmipp3_installer/installer/modes/mode_cmake/mode_compile_and_install_executor.py

@@ -0,0 +1,49 @@
+from typing import Tuple, Dict
+
+from xmipp3_installer.application.cli.arguments import params
+from xmipp3_installer.application.logger import predefined_messages, errors
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.handlers import shell_handler
+from xmipp3_installer.installer.modes.mode_cmake import mode_cmake_executor
+
+class ModeCompileAndInstallExecutor(mode_cmake_executor.ModeCMakeExecutor):
+	def __init__(self, context: Dict):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- context (dict): Dictionary containing the installation context variables.
+		"""
+		super().__init__(context)
+		self.jobs = context[params.PARAM_JOBS]
+
+	def _set_executor_config(self):
+		"""
+		### Sets the specific executor params for this mode.
+		"""
+		super()._set_executor_config()
+		self.prints_banner_on_exit = True
+
+	def _run_cmake_mode(self, cmake: str) -> Tuple[int, str]:
+		"""
+		### Runs the CMake compilation & installation with the appropiate params.
+
+		#### Params:
+		- cmake (str): Path to CMake executable.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the error status and an error message if there was an error. 
+		"""
+		logger(predefined_messages.get_section_message("Compiling with CMake"))
+		cmd = f"{cmake} --build {paths.BUILD_PATH} --config {self.build_type} -j {self.jobs}"
+		if shell_handler.run_shell_command_in_streaming(cmd, show_output=True, substitute=self.substitute):
+			return errors.CMAKE_COMPILE_ERROR, ""
+		
+		installation_section_message = predefined_messages.get_section_message("Installing with CMake")
+		logger(f"\n{installation_section_message}")
+		cmd = f"{cmake} --install {paths.BUILD_PATH} --config {self.build_type}"
+		if shell_handler.run_shell_command_in_streaming(cmd, show_output=True, substitute=self.substitute):
+			return errors.CMAKE_INSTALL_ERROR, ""
+		return 0, ""
+	

xmipp3_installer/installer/modes/mode_cmake/mode_config_build_executor.py

@@ -0,0 +1,64 @@
+from typing import Tuple, List, Optional, Union
+
+from xmipp3_installer.application.logger import predefined_messages, errors
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.handlers import shell_handler
+from xmipp3_installer.installer.modes.mode_cmake import mode_cmake_executor
+from xmipp3_installer.repository.config_vars import variables
+
+class ModeConfigBuildExecutor(mode_cmake_executor.ModeCMakeExecutor):
+	def _run_cmake_mode(self, cmake: str) -> Tuple[int, str]:
+		"""
+		### Runs the CMake config with the appropiate params.
+
+		#### Params:
+		- cmake (str): Path to CMake executable.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the error status and an error message if there was an error. 
+		"""
+		logger(predefined_messages.get_section_message("Configuring with CMake"))
+		cmd = f"{cmake} -S . -B {paths.BUILD_PATH} -DCMAKE_BUILD_TYPE={self.build_type} {self.__get_cmake_vars()}"
+		if shell_handler.run_shell_command_in_streaming(cmd, show_output=True, substitute=self.substitute):
+			return errors.CMAKE_CONFIGURE_ERROR, ""
+		return 0, ""
+	
+	def __get_cmake_vars(self) -> str:
+		"""
+		### Returns the CMake variables required for the configuration step.
+
+		#### Returns:
+		- (str): String containing all required CMake variables
+		"""
+		return " ".join([
+			f"-D{variable_key}={self.context[variable_key]}" for variable_key
+			in self.__get_config_vars() if not self.__is_empty(self.context[variable_key])
+		])
+	
+	def __get_config_vars(self) -> List[str]:
+		"""
+		### Returns all non-internal config variable keys.
+
+		#### Returns:
+		- (list(str)): A list containing all non-internal config variable keys.
+		"""
+		all_config_var_keys = [
+			config_var for variable_section in variables.CONFIG_VARIABLES.values()
+			for config_var in variable_section
+		]
+		non_internal_keys = list(set(all_config_var_keys) - set(variables.INTERNAL_LOGIC_VARS))
+		non_internal_keys.sort() # To keep order consistency
+		return non_internal_keys
+
+	def __is_empty(self, value: Optional[Union[bool, str]]) -> bool:
+		"""
+		### Checks if the given config value is empty.
+
+		#### Params:
+		- value (bool | str | None): Value to be checked.
+
+		#### Returns:
+		- (bool): True if it is empty, False otherwise.
+		"""
+		return value is None or value == ""

xmipp3_installer/installer/modes/mode_config_executor.py

@@ -0,0 +1,46 @@
+import os
+from typing import Dict, Tuple
+
+from xmipp3_installer.application.logger import errors
+from xmipp3_installer.application.logger import predefined_messages
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.application.cli.arguments import params
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.modes import mode_executor
+from xmipp3_installer.repository import config
+
+class ModeConfigExecutor(mode_executor.ModeExecutor):
+	def __init__(self, context: Dict):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- context (dict): Dictionary containing the installation context variables.
+		"""
+		super().__init__(context)
+		self.overwrite = context.pop(params.PARAM_OVERWRITE)
+		self.config_values = {}
+	
+	def run(self) -> Tuple[int, str]:
+		"""
+		### Reads the config file and writes to it formatting properly with the appropiate values.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the error status and an error message if there was an error. 
+		"""
+		logger(predefined_messages.get_section_message("Managing config file"))
+		action_message = (
+			"Generating config file from scratch with default values..."
+			if self.overwrite or not os.path.exists(paths.CONFIG_FILE) else
+			"Reading config file..."
+		)
+		logger(action_message)
+		try:
+			file_handler = config.ConfigurationFileHandler()
+			file_handler.write_config(overwrite=self.overwrite)
+		except PermissionError as permission_error:
+			return errors.IO_ERROR, str(permission_error)
+		self.config_values = file_handler.values
+		logger(predefined_messages.get_done_message())
+		return 0, ""
+	

xmipp3_installer/installer/modes/mode_executor.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Tuple
+
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer.constants import paths
+
+class ModeExecutor(ABC):
+  """
+  ### Base executor interface for installer modes.
+  """
+  def __init__(self, context: Dict):
+    """
+		### Constructor.
+		
+		#### Params:
+		- context (dict): Dictionary containing the installation context variables.
+		"""
+    super().__init__()
+    self.context = context
+    self._set_executor_config()
+    self.__configure_logger()
+  
+  def _set_executor_config(self):
+    """
+    ### Sets the specific executor params for this mode.
+    """
+    self.logs_to_file = False
+    self.prints_with_substitution = False
+    self.prints_banner_on_exit = False
+    self.sends_installation_info = False
+  
+  def __configure_logger(self):
+    """
+    ### Configures the logger according to the specified config.
+    """
+    if self.logs_to_file:
+      logger.start_log_file(paths.LOG_FILE)
+    if self.prints_with_substitution:
+      logger.set_allow_substitution(True)
+  
+  @abstractmethod
+  def run(self) -> Tuple[int, str]:
+    """Run method to be implemented by inheriting classes."""

xmipp3_installer/installer/modes/mode_get_sources_executor.py

@@ -0,0 +1,132 @@
+import os
+from typing import Dict, Tuple, Optional
+
+from xmipp3_installer.application.cli.arguments import params
+from xmipp3_installer.application.logger import predefined_messages, errors
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer import constants, urls
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.modes import mode_executor
+from xmipp3_installer.installer.handlers import git_handler, versions_manager, shell_handler
+
+class ModeGetSourcesExecutor(mode_executor.ModeExecutor):
+	def __init__(self, context: Dict):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- context (dict): Dictionary containing the installation context variables.
+		- substitute (bool): Optional. If True, printed text will be substituted with the next message.
+		"""
+		super().__init__(context)
+		self.substitute = not context[params.PARAM_KEEP_OUTPUT]
+		self.target_branch = context.pop(params.PARAM_BRANCH)
+		versions: versions_manager.VersionsManager = context[constants.VERSIONS_CONTEXT_KEY]
+		self.xmipp_tag_name = versions.xmipp_version_name
+		self.source_versions: Dict = versions.sources_versions
+	
+	def run(self) -> Tuple[int, str]:
+		"""
+		### Executes the given git command into all xmipp source repositories.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the return code and an error message if there was an error.
+		"""
+		logger(predefined_messages.get_section_message("Getting Xmipp sources"))
+		for source in constants.XMIPP_SOURCES:
+			ret_code, output = self.__get_source(source)
+			if ret_code:
+				return errors.SOURCE_CLONE_ERROR, output
+		return 0, ""
+	
+	def _set_executor_config(self):
+		"""
+		### Sets the specific executor params for this mode.
+		"""
+		super()._set_executor_config()
+		self.prints_with_substitution = True
+	
+	def __select_ref_to_clone(self, source_name: str, source_repo: str) -> str:
+		"""
+		### Selects the reference to clone from the source.
+
+		#### Params:
+		- source_name (str): Name of the source to clone.
+		- source_repo (str): URL of the source's repository.
+
+		#### Returns:
+		- (str): The reference name to clone.
+		"""
+		current_branch = git_handler.get_current_branch()
+		tag_name = None
+		if (
+			not current_branch or
+			current_branch == constants.MASTER_BRANCHNAME or
+			current_branch == self.xmipp_tag_name
+		):
+			tag_name = self.source_versions.get(source_name)
+		return git_handler.get_clonable_branch(source_repo, self.target_branch, tag_name)
+	
+	def __run_source_command(self, source_name: str, source_repo: str, target_branch: Optional[str]) -> Tuple[int, str]:
+		"""
+		### Executes git clone/checkout commands for a source repository.
+		
+		If the source already exists locally:
+		- If target_branch is specified, checks out that branch.
+		- If no target_branch, returns success without changes.
+		
+		If the source doesn't exist:
+		- Clones the repository with the specified branch.
+		- If no branch specified, clones with default branch.
+
+		#### Params:
+		- source_name (str): Name of the source repository.
+		- source_repo (str): URL of the git repository to clone from.
+		- target_branch (str | None): Branch or tag to checkout/clone.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the return code and the text output produced by the command.
+		"""
+		source_path = paths.get_source_path(source_name)
+		if os.path.exists(source_path):
+			if not target_branch:
+				return 0, ""
+			return shell_handler.run_shell_command(
+				f"git checkout {target_branch}",
+				cwd=source_path
+			)
+		
+		branch_str = (
+			f"{params.PARAMS[params.PARAM_BRANCH][params.LONG_VERSION]} {target_branch}"
+			if target_branch else ""
+		)
+		return shell_handler.run_shell_command(f"git clone{branch_str} {source_repo}.git", cwd=paths.SOURCES_PATH)
+	
+	def __get_source(self, source_name: str) -> Tuple[int, str]:
+		"""
+		### Gets the given source.
+		
+		It is cloned if it does not already exist locally.
+
+		#### Params:
+		- source_name (str): Name of the source to clone.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the return code and the text output produced by the command.
+		"""
+		repo_url = f"{urls.I2PC_REPOSITORY_URL}{source_name}"
+		logger(f"Cloning {source_name}...", substitute=self.substitute)
+		logger(predefined_messages.get_working_message(), substitute=self.substitute)
+
+		clone_branch = self.__select_ref_to_clone(source_name, repo_url)
+		if self.target_branch and not clone_branch:
+			warning_message = logger.yellow("\n".join([
+				f"Warning: branch \'{self.target_branch}\' does not exist for repository with url {repo_url}.",
+				"Falling back to repository's default branch."
+			]))
+			logger(warning_message, substitute=self.substitute)
+		
+		ret_code, output = self.__run_source_command(source_name, repo_url, clone_branch)
+		if not ret_code:
+			logger(predefined_messages.get_done_message(), substitute=self.substitute)
+		return ret_code, output

xmipp3_installer/installer/modes/mode_git_executor.py

@@ -0,0 +1,41 @@
+from typing import Dict, Tuple
+
+from xmipp3_installer.application.cli.arguments import params
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer import constants
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.modes import mode_executor
+from xmipp3_installer.installer.handlers import git_handler
+
+class ModeGitExecutor(mode_executor.ModeExecutor):
+	def __init__(self, context: Dict):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- context (dict): Dictionary containing the installation context variables.
+		"""
+		super().__init__(context)
+		command_param_list = context.pop(params.PARAM_GIT_COMMAND)
+		self.command = ' '.join(command_param_list)
+	
+	def run(self) -> Tuple[int, str]:
+		"""
+		### Executes the given git command into all xmipp source repositories.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the return code and an error message if there was an error.
+		"""
+		logger(f"Running command 'git {self.command}' for all xmipp sources...")
+
+		for source in [constants.XMIPP, *constants.XMIPP_SOURCES]:
+			logger("\n" + logger.blue(
+				f"Running command for {source} in path {paths.get_source_path(source)}..."
+			))
+			ret_code, output = git_handler.execute_git_command_for_source(
+				self.command, source
+			)
+			if ret_code:
+				return ret_code, output
+
+		return 0, ""

xmipp3_installer/installer/modes/mode_selector.py

@@ -0,0 +1,25 @@
+from xmipp3_installer.application.cli.arguments import modes
+from xmipp3_installer.installer.modes import (
+  mode_config_executor, mode_version_executor, mode_git_executor,
+  mode_get_sources_executor, mode_all_executor
+)
+from xmipp3_installer.installer.modes.mode_clean import mode_clean_all_executor, mode_clean_bin_executor
+from xmipp3_installer.installer.modes.mode_sync import (
+  mode_add_model_executor, mode_get_models_executor, mode_test_executor
+)
+from xmipp3_installer.installer.modes.mode_cmake import mode_config_build_executor, mode_compile_and_install_executor
+
+MODE_EXECUTORS = {
+  modes.MODE_ADD_MODEL: mode_add_model_executor.ModeAddModelExecutor,
+  modes.MODE_ALL: mode_all_executor.ModeAllExecutor,
+  modes.MODE_CLEAN_ALL: mode_clean_all_executor.ModeCleanAllExecutor,
+  modes.MODE_CLEAN_BIN: mode_clean_bin_executor.ModeCleanBinExecutor,
+  modes.MODE_COMPILE_AND_INSTALL: mode_compile_and_install_executor.ModeCompileAndInstallExecutor,
+  modes.MODE_CONFIG_BUILD: mode_config_build_executor.ModeConfigBuildExecutor,
+  modes.MODE_CONFIG: mode_config_executor.ModeConfigExecutor,
+  modes.MODE_GET_MODELS: mode_get_models_executor.ModeGetModelsExecutor,
+  modes.MODE_GET_SOURCES: mode_get_sources_executor.ModeGetSourcesExecutor,
+  modes.MODE_GIT: mode_git_executor.ModeGitExecutor,
+  modes.MODE_TEST: mode_test_executor.ModeTestExecutor,
+  modes.MODE_VERSION: mode_version_executor.ModeVersionExecutor
+}