xmipp3-installer 1.0.0__py3-none-any.whl

xmipp3_installer/installer/handlers/cmake/cmake_handler.py

@@ -0,0 +1,69 @@
+"""### Functions that interact with CMake."""
+
+import os
+import shutil
+from typing import Dict, Any
+
+from xmipp3_installer.installer.handlers.cmake import cmake_constants
+from xmipp3_installer.repository.config_vars import variables
+
+def get_cmake_path(config: Dict[str, Any]) -> str:
+	"""
+	### Retrieves information about the CMake package and updates the dictionary accordingly.
+
+	#### Params:
+	- packages (dict): Dictionary containing package information.
+
+	#### Returns:
+	- (dict): Param 'packages' with the 'CMAKE' key updated based on the availability of 'cmake'.
+	"""
+	return config.get(variables.CMAKE) or shutil.which(cmake_constants.DEFAULT_CMAKE)
+
+def get_cmake_vars_str(config: Dict[str, Any]) -> str:
+	"""
+	### Converts the variables in the config dictionary into a list as CMake args.
+	
+	#### Params:
+	- config (dict): Dictionary to obtain the parameters from.
+	"""
+	result = []
+	for (key, value) in config.items():
+		if key not in variables.INTERNAL_LOGIC_VARS and bool(value):
+			result.append(f"-D{key}={value}")
+	return ' '.join(result)
+
+def get_library_versions_from_cmake_file(path: str) -> Dict[str, Any]:
+	"""
+	### Obtains the library versions from the CMake cache file.
+
+	#### Params:
+	- path (str): Path to the file containing all versions.
+
+	#### Returns:
+	- (dict(str, any)): Dictionary containing all the library versions in the file.
+	"""
+	if not os.path.exists(path):
+		return {}
+	
+	result = {}
+	with open(path, 'r') as versions_file:
+		for line in versions_file.readlines():
+			result.update(__get_library_version_from_line(line))
+	return result
+
+def __get_library_version_from_line(version_line: str) -> Dict[str, Any]:
+	"""
+	### Retrieves the name and version of the library in the given line.
+	
+	#### Params:
+	- version_line (str): Text line containing the name and version of the library.
+	
+	#### Returns:
+	- (dict(str, any)): Dictionary where the key is the name and the value is the version.
+	"""
+	library_with_version = {}
+	name_and_version = version_line.replace("\n", "").split('=')
+	if len(name_and_version) == 2:
+		version = name_and_version[1] if name_and_version[1] else None
+		library_with_version[name_and_version[0]] = version
+	return library_with_version

xmipp3_installer/installer/handlers/conda_handler.py

@@ -0,0 +1,13 @@
+"""### Functions that interact with Conda via shell."""
+
+import os
+from typing import Optional
+
+def get_conda_prefix_path() -> Optional[str]:
+	"""
+	### Returns the path for the current Conda enviroment.
+
+	#### Returns:
+	- (str | None): Path for current Conda enviroment.
+	"""
+	return os.environ.get('CONDA_PREFIX')

xmipp3_installer/installer/handlers/generic_package_handler.py

@@ -0,0 +1,18 @@
+"""### Contains functions that can interact with packages via shell with a generic interface."""
+
+from typing import Optional
+
+from xmipp3_installer.installer.handlers import shell_handler
+
+def get_package_version(package_name: str) -> Optional[str]:
+	"""
+	### Retrieves the version of a package or program by executing '[package_name] --version' command.
+
+	Params:
+	- package_name (str): Name of the package or program.
+
+	Returns:
+	- (str | None): Version information of the package or None if not found or errors happened.
+	"""
+	ret_code, output = shell_handler.run_shell_command(f'{package_name} --version')
+	return output if ret_code == 0 else None

xmipp3_installer/installer/handlers/git_handler.py

@@ -0,0 +1,185 @@
+"""### Functions that interact with Git via shell."""
+
+import os
+from typing import Optional, Tuple
+
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.handlers import shell_handler
+
+def get_current_branch(dir: str='./') -> str:
+	"""
+	### Returns the current branch of the repository of the given directory or empty string if it is not a repository or a recognizable tag.
+	
+	#### Params:
+	- dir (str): Optional. Directory of the repository to get current branch from. Default is current directory.
+	
+	#### Returns:
+	- (str): The name of the branch, 'HEAD' if a tag, or empty string if given directory is not a repository or a recognizable tag.
+	"""
+	ret_code, branch_name = shell_handler.run_shell_command("git rev-parse --abbrev-ref HEAD", cwd=dir)
+	# If there was an error, we are in no branch
+	return branch_name if not ret_code else ''
+
+def is_tag(dir: str='./') -> bool:
+	"""
+	### Returns True if the current Xmipp repository is in a tag.
+
+	#### Params:
+	- dir (str): Optional. Directory of the repository where the check will happen. Default is current directory.
+	
+	#### Returns:
+	- (bool): True if the repository is a tag. False otherwise.
+	"""
+	current_branch = get_current_branch(dir=dir)
+	return not current_branch or current_branch == "HEAD"
+
+def is_branch_up_to_date(dir: str='./') -> bool:
+	"""
+	### Returns True if the current branch is up to date, or False otherwise or if some error happened.
+	
+	#### Params:
+	- dir (str): Optional. Directory of the repository to get current branch from. Default is current directory.
+	
+	#### Returns:
+	- (bool): True if the current branch is up to date, or False otherwise or if some error happened.
+	"""
+	current_branch = get_current_branch(dir=dir)
+	if not current_branch:
+		return False
+	
+	ret_code = shell_handler.run_shell_command("git fetch", cwd=dir)[0]
+	if ret_code != 0:
+		return False
+
+	latest_local_commit = shell_handler.run_shell_command(f"git rev-parse {current_branch}", cwd=dir)[1]
+	ret_code, latest_remote_commit = shell_handler.run_shell_command(f"git rev-parse origin/{current_branch}")
+	if ret_code != 0:
+		return False
+	
+	return latest_local_commit == latest_remote_commit
+
+def get_current_commit(dir: str="./") -> str:
+	"""
+	### Rreturns the current commit short hash of a given repository:
+
+	#### Params:
+	- dir (str): Optional. Directory of repository.
+
+	#### Returns:
+	- (str): Current commit short hash, or empty string if it is not a repo or there were errors.
+	"""
+	ret_code, output = shell_handler.run_shell_command("git rev-parse --short HEAD", cwd=dir)
+	if ret_code or not output:
+		return ''
+	return output
+
+def get_commit_branch(commit: str, dir: str="./") -> str:
+	"""
+	### Returns the name of the commit branch. It can be a branch name or a release name.
+
+	#### Params:
+	- commit (str): Commit hash.
+	- dir (str): Optional. Directory to repository.
+
+	#### Returns:
+	- (str): Name of the commit branch or release.
+	"""
+	ret_code, output = shell_handler.run_shell_command(f"git name-rev {commit}", cwd=dir)
+	if ret_code or not output:
+		return ''
+	return output.replace(commit, "").replace(" ", "")
+
+def branch_exists_in_repo(repo_url: str, branch: str) -> bool:
+	"""
+	### Checks if the given branch exists in the given repository.
+
+	#### Params:
+	- repo (str): Repository to check from.
+	- branch (str): Name of the branch to check for.
+
+	#### Returns:
+	- (bool): True if the branch exists, False otherwise.
+	"""
+	return __ref_exists_in_repo(repo_url, branch, True)
+
+def tag_exists_in_repo(repo_url: str, tag: str) -> bool:
+	"""
+	### Checks if the given tag exists in the given repository.
+
+	#### Params:
+	- repo_url (str): Repository to check from.
+	- tag (str): Name of the tag to check for.
+
+	#### Returns:
+	- (bool): True if the tag exists, False otherwise.
+	"""
+	return __ref_exists_in_repo(repo_url, tag, False)
+
+def get_clonable_branch(repo_url: str, preferred_branch: str, viable_tag: str) -> Optional[str]:
+	"""
+	### Decides the target to be cloned from a given repository.
+
+	The preferred branch will be selected if exists,
+	followed in priority by the viable tag if provided.
+	Finally, if no branch could be selected, None is returned,
+	meaning that repository's default branch will be used.
+
+	#### Params:
+	- repo_url (str): Url of the repositori to be cloned.
+	- preferred_branch (str): Preferred branch to clone into.
+	- viable_tag (str): If exists, it is returned if branch does not.
+
+	#### Returns:
+	- (str): Name of the branch to clone the repository into.
+	"""
+	if preferred_branch and branch_exists_in_repo(repo_url, preferred_branch):
+		return preferred_branch
+	if viable_tag and tag_exists_in_repo(repo_url, viable_tag):
+		return viable_tag
+	return None
+
+def execute_git_command_for_source(command: str, source: str) -> Tuple[int, str]:
+	"""
+	### Executes the git command for a specific source.
+
+	#### Params:
+	- command (str): Command to execute on the source.
+	- source (str): The source repository name.
+
+	#### Returns:
+	- (tuple(int, str)): Tuple containing the return code and output message.
+	"""
+	source_path = paths.get_source_path(source)
+	if not os.path.exists(source_path):
+		logger(logger.yellow(
+			f"WARNING: Source {source} does not exist in path {source_path}. Skipping."
+		))
+		return 0, ""
+	
+	return shell_handler.run_shell_command(
+		f"git {command}",
+		cwd=source_path,
+		show_output=True,
+		show_error=True
+	)
+
+def __ref_exists_in_repo(repo_url: str, ref: str, is_branch: bool) -> bool:
+	"""
+	### Checks if a given reference exists in the given repository.
+
+	#### Params:
+	- repo_url (str): Repository to check from.
+	- ref (str): Reference to check for.
+	- is_branch (bool): If True, the reference is a branch. If False, it is a tag.
+
+	#### Returns:
+	- (bool): True if the ref exists, False otherwise.
+	"""
+	ref_type = "heads" if is_branch else "tags"
+	ret_code, output = shell_handler.run_shell_command(
+		f"git ls-remote --{ref_type} {repo_url}.git refs/{ref_type}/{ref}"
+	)
+	if ret_code:
+		return False
+	return f"refs/{ref_type}/{ref}" in output

xmipp3_installer/installer/handlers/shell_handler.py

@@ -0,0 +1,114 @@
+"""### Functions that interact with the shell."""
+
+import os
+import subprocess
+import threading
+
+from typing import Tuple
+
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.application.logger import errors
+
+def run_shell_command(
+	cmd: str,
+	cwd: str='./',
+	show_command: bool=False,
+	show_output: bool=False,
+	show_error: bool=False,
+	substitute: bool=False
+) -> Tuple[int, str]:
+	"""
+	### This function runs the given command.
+
+	#### Params:
+	- cmd (str): Command to run.
+	- cwd (str): Optional. Path to run the command from. Default is current directory.
+	- show_output (bool): Optional. If True, output is printed.
+	- show_error (bool): Optional. If True, errors are printed.
+	- show_command (bool): Optional. If True, command is printed in blue.
+	- substitute (bool): Optional. If True, output will replace previous line.
+
+	#### Returns:
+	- (int): Return code.
+	- (str): Output of the command, regardless of if it is an error or regular output.
+	"""
+	if show_command:
+		logger(logger.blue(cmd), substitute=substitute)
+	ret_code, output_str = __run_command(cmd, cwd=cwd)
+
+	if not ret_code and show_output:
+		logger(output_str, substitute=substitute)
+	
+	if ret_code and show_error:
+		logger.log_error(output_str, ret_code=ret_code)
+	
+	return ret_code, output_str
+
+def run_shell_command_in_streaming(
+	cmd: str,
+	cwd: str='./',
+	show_output: bool=False,
+	show_error: bool=False,
+	substitute: bool=False
+) -> int:
+	"""
+	### Runs the given command and shows its output as it is being generated.
+
+	#### Params:
+	- cmd (str): Command to run.
+	- cwd (str): Optional. Path to run the command from. Default is current directory.
+	- show_output (bool): Optional. If True, output is printed.
+	- show_error (bool): Optional. If True, errors are printed.
+	- substitute (bool): Optional. If True, output will replace previous line.
+
+	#### Returns:
+	- (int): Return code.
+	"""
+	logger(cmd)
+	process = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+	
+	thread_out = threading.Thread(
+		target=logger.log_in_streaming,
+		args=(process.stdout,),
+		kwargs={"show_in_terminal": show_output, "substitute": substitute, "err": False}
+	)
+	thread_err = threading.Thread(
+		target=logger.log_in_streaming,
+		args=(process.stderr,),
+		kwargs={"show_in_terminal": show_error, "substitute": substitute, "err": True}
+	)
+	thread_out.start()
+	thread_err.start()
+
+	try:
+		process.wait()
+		thread_out.join()
+		thread_err.join()
+	except KeyboardInterrupt:
+		process.returncode = errors.INTERRUPTED_ERROR
+	
+	return process.returncode
+
+def __run_command(cmd: str, cwd: str='./') -> Tuple[int, str]:
+	"""
+	### Runs the given shell command.
+
+	#### Params:
+	- cmd (str): Command to run.
+	- cwd (str): Optional. Path to run the command from.
+
+	#### Returns:
+	- (int): Return code of the operation.
+	- (str): Return message of the operation.
+	"""
+	process = subprocess.Popen(cmd, cwd=cwd, env=os.environ, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+	try:
+		process.wait()
+	except KeyboardInterrupt:
+		return errors.INTERRUPTED_ERROR, ""
+	
+	ret_code = process.returncode
+	output, err = process.communicate()
+	output_str = output.decode() if not ret_code and output else err.decode()
+	output_str = output_str[:-1] if output_str.endswith('\n') else output_str
+	return ret_code, output_str

xmipp3_installer/installer/handlers/versions_manager.py

@@ -0,0 +1,98 @@
+import json
+from datetime import datetime
+from typing import Dict, List
+
+from xmipp3_installer.installer import constants
+from xmipp3_installer.shared import singleton
+
+class VersionsManager(singleton.Singleton):
+  def __init__(self, version_file_path: str):
+    """
+    ### Constructor.
+    
+    Initializes the version manager by reading and validating version information from a JSON file.
+
+    #### Params:
+    - version_file_path (str): Path to the JSON file containing version information.
+
+    #### Raises:
+    - ValueError: If version numbers don't follow semver format (x.y.z) or release date isn't dd/mm/yyyy.
+    """
+    super().__init__()
+    self.version_file_path = version_file_path
+    version_info = self.__get_version_info()
+    self.xmipp_version_number = version_info[constants.XMIPP]["version_number"]
+    self.xmipp_version_name = version_info[constants.XMIPP]["version_name"]
+    self.xmipp_release_date = version_info[constants.XMIPP]["release_date"]
+    self.sources_versions = version_info["sources_target_tag"]
+    self.__validate_fields()
+
+  def __get_version_info(self) -> Dict[str, str]:
+    """
+    ### Retrieves the version info from the version information JSON file.
+
+    #### Returns:
+    - (dict(str, str)): Dictionary containing the parsed values.
+    """
+    with open(self.version_file_path) as json_data:
+      version_info = json.load(json_data)
+    return version_info
+  
+  def __validate_fields(self):
+    """
+    ### Validates version numbers and release date format.
+    
+    Checks that:
+    - Version numbers follow semantic versioning (x.y.z)
+    - Release date follows dd/mm/yyyy format
+
+    #### Raises:
+    - ValueError: If any field doesn't match its required format.
+    """
+    self.__validate_version_number()
+    self.__validate_release_date()
+
+  def __validate_version_number(self):
+    """
+    ### Validates that version numbers follow semantic versioning format.
+    
+    Checks that version numbers are in x.y.z format where x, y, z are integers.
+
+    #### Raises:
+    - ValueError: If any version number doesn't follow the required format.
+    """
+    parts = self.xmipp_version_number.split('.')
+    if not self.__is_valid_semver(parts):
+      raise ValueError(
+        f"Version number '{self.xmipp_version_number}' is invalid. Must be three numbers separated by dots (x.y.z)."
+      )
+
+  def __is_valid_semver(self, version_parts: List[str]) -> bool:
+    """
+    ### Checks if version parts constitute a valid semantic version.
+    
+    #### Params:
+    - version_parts (list(str)): List of strings representing version number parts.
+
+    #### Returns:
+    - (bool): True if version follows semver format, False otherwise.
+    """
+    return len(version_parts) == 3 and all(part.isdigit() for part in version_parts)
+
+  def __validate_release_date(self):
+    """
+    ### Validates that release date follows dd/mm/yyyy format.
+    
+    Checks that:
+    - Date string follows dd/mm/yyyy format
+    - Date is a valid calendar date
+
+    #### Raises:
+    - ValueError: If release date doesn't follow the required format or is invalid.
+    """
+    try:
+      datetime.strptime(self.xmipp_release_date, "%d/%m/%Y")
+    except ValueError:
+      raise ValueError(
+        f"Release date '{self.xmipp_release_date}' is invalid. Must be in dd/mm/yyyy format."
+      )

xmipp3_installer/installer/installer_service.py

@@ -0,0 +1,66 @@
+from typing import Dict
+
+from xmipp3_installer.api_client import api_client
+from xmipp3_installer.api_client.assembler import installation_info_assembler
+from xmipp3_installer.application.cli.arguments import modes
+from xmipp3_installer.application.logger import errors
+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.handlers import versions_manager
+from xmipp3_installer.installer.modes.mode_executor import ModeExecutor
+from xmipp3_installer.application.logger import predefined_messages
+from xmipp3_installer.installer.modes import mode_selector
+from xmipp3_installer.repository import config
+from xmipp3_installer.repository.config_vars import variables
+
+class InstallationManager:
+  def __init__(self, args: Dict):
+    """
+		### Constructor.
+		
+		#### Params:
+		- args (dict): Dictionary containing all parsed command-line arguments.
+		"""
+    self.mode = args.pop(modes.MODE, modes.MODE_ALL)
+    config_handler = config.ConfigurationFileHandler(path=paths.CONFIG_FILE, show_errors=False)
+    self.context = {
+      **args,
+      **config_handler.values,
+      variables.LAST_MODIFIED_KEY: config_handler.last_modified,
+      constants.VERSIONS_CONTEXT_KEY: versions_manager.VersionsManager(paths.VERSION_INFO_FILE)
+    }
+    self.mode_executor: ModeExecutor = mode_selector.MODE_EXECUTORS[self.mode](self.context)
+
+  def run_installer(self):
+    """
+    ### Runs the installer with the given arguments.
+
+    #### Returns:
+    - (int): Return code.
+    """
+    try:
+      ret_code, output = self.mode_executor.run()
+    except KeyboardInterrupt:
+      logger.log_error("", ret_code=errors.INTERRUPTED_ERROR, add_portal_link=False)
+      return errors.INTERRUPTED_ERROR
+    if ret_code:
+      logger.log_error(output, ret_code=ret_code, add_portal_link=ret_code != errors.INTERRUPTED_ERROR)
+    if (
+      self.mode_executor.sends_installation_info and 
+      self.context[variables.SEND_INSTALLATION_STATISTICS]
+    ):
+      logger("Sending anonymous installation info...")
+      api_client.send_installation_attempt(
+        installation_info_assembler.get_installation_info(
+          self.context[constants.VERSIONS_CONTEXT_KEY],
+          ret_code=ret_code
+        )
+      )
+    if not ret_code and self.mode_executor.prints_banner_on_exit:
+      logger(predefined_messages.get_success_message(
+        self.context[constants.VERSIONS_CONTEXT_KEY].xmipp_version_number
+      ))
+    logger.close()
+    return ret_code
+  

xmipp3_installer/installer/modes/__init__.py

@@ -0,0 +1 @@
+"""### Contains the executors for each mode."""

xmipp3_installer/installer/modes/mode_all_executor.py

@@ -0,0 +1,63 @@
+from typing import Tuple, Dict
+
+from xmipp3_installer.application.cli.arguments import params
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer.modes import (
+	mode_executor, mode_config_executor, mode_get_sources_executor
+)
+from xmipp3_installer.installer.modes.mode_cmake import (
+	mode_config_build_executor, mode_compile_and_install_executor
+)
+
+class ModeAllExecutor(mode_executor.ModeExecutor):
+	def __init__(self, context: Dict):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- context (dict): Dictionary containing the installation context variables.
+		"""
+		config_executor = mode_config_executor.ModeConfigExecutor(
+			{**context, params.PARAM_OVERWRITE: False}
+		)
+		get_sources_executor = mode_get_sources_executor.ModeGetSourcesExecutor(
+			context
+		)
+		config_build_executor = mode_config_build_executor.ModeConfigBuildExecutor(
+			context
+    )
+		compile_and_install_executor = mode_compile_and_install_executor.ModeCompileAndInstallExecutor(
+			{**context, params.PARAM_BRANCH: None}
+    )
+		self.executors = [
+			config_executor,
+			get_sources_executor,
+			config_build_executor,
+			compile_and_install_executor
+		]
+		super().__init__(context)
+
+	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
+		self.prints_banner_on_exit = True
+		self.sends_installation_info = True
+
+	def run(self) -> Tuple[int, str]:
+		"""
+		### Runs the whole installation process with the appropiate params.
+
+		#### Returns:
+		- (tuple(int, str)): Tuple containing the error status and an error message if there was an error. 
+		"""
+		for executor_index in range(len(self.executors)):
+			if executor_index != 0:
+				logger("")
+			ret_code, output = self.executors[executor_index].run()
+			if ret_code:
+				return ret_code, output
+		return 0, ""

xmipp3_installer/installer/modes/mode_clean/__init__.py

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

xmipp3_installer/installer/modes/mode_clean/mode_clean_all_executor.py

@@ -0,0 +1,44 @@
+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 ModeCleanAllExecutor(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.
+		"""
+		return [
+			*[paths.get_source_path(source) for source in constants.XMIPP_SOURCES],
+			paths.INSTALL_PATH,
+			paths.BUILD_PATH,
+			paths.CONFIG_FILE
+		]
+	
+	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 "YeS"
+
+	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("WARNING: This will DELETE ALL content from src and build, and also the xmipp.conf file."),
+			logger.yellow("\tNotice that if you have unpushed changes, they will be deleted."),
+			logger.yellow(f"\nIf you are sure you want to do this, type '{self._get_confirmation_keyword()}' (case sensitive):")
+		])
+