xmipp3-installer 1.0.0__py3-none-any.whl

xmipp3_installer/application/cli/parsers/general_help_formatter.py

@@ -0,0 +1,92 @@
+"""### Help formatter specific for generic usage mode."""
+
+from xmipp3_installer.application.cli.arguments import modes
+from xmipp3_installer.application.cli.parsers import format
+from xmipp3_installer.application.cli.parsers.base_help_formatter import BaseHelpFormatter
+from xmipp3_installer.application.logger.logger import logger
+
+class GeneralHelpFormatter(BaseHelpFormatter):
+	"""
+	### Overrides the default help formatter to display a custom help message.
+	"""
+	def format_help(self):
+		"""
+		### Prints the help message of the argument parser.
+		"""
+		help_message = "Run Xmipp's installer script\n\nUsage: xmipp [options]\n"
+		for section in list(modes.MODES.keys()):
+			help_message += self.__get_section_message(section)
+		help_message += f"\n{self.__get_epilog()}"
+		help_message += self.__get_note()
+		return format.get_formatting_tabs(help_message)
+	
+	def __get_mode_args_str(self, mode: str) -> str:
+		"""
+		### This method returns the args text for a given mode.
+
+		### Params:
+		- mode (str): Mode to get args text for.
+
+		### Returns:
+		- (str): Args text for given mode.
+		"""
+		arg_list = modes.MODE_ARGS[mode]
+		param_names = []
+		for param in arg_list:
+			param_name = self._get_param_first_name(param)
+			if param_name:
+				param_names.append(f'[{param_name}]')
+		return ' '.join(param_names)
+
+	def __get_mode_args_and_help_str(self, previous_text: str, mode: str) -> str:
+		"""
+		### This method returns the args and help text for a given mode.
+
+		### Params:
+		- previous_text (str): Text inserted before the one to be returned.
+		- mode (str): Mode to get help text for.
+
+		### Returns:
+		- (str): Args and help text for given mode.
+		"""
+		return self._text_with_limits(
+			previous_text + self.__get_mode_args_str(mode),
+			self._get_mode_help(mode)
+		)
+
+	def __get_epilog(self) -> str:
+		"""
+		### Returns the epilogue.
+
+		#### Returns:
+		- (str): Epilogue.
+		"""
+		epilogue = "Example 1: ./xmipp\n"
+		epilogue += "Example 2: ./xmipp compileAndInstall -j 4\n"
+		return epilogue
+	
+	def __get_note(self) -> str:
+		"""
+		### Returns the additional note message.
+
+		#### Returns:
+		- (str): Note message.
+		"""
+		note_message = "Note: You can also view a specific help message for each mode with \"./xmipp [mode] -h\".\n"
+		note_message += f"Example: ./xmipp {modes.MODE_ALL} -h\n"
+		return logger.yellow(note_message)
+
+	def __get_section_message(self, section: str) -> str:
+		"""
+		### Returns the given section's message.
+
+		#### Params:
+		- section (str): Section name.
+
+		#### Return:
+		- (str): Section's message.
+		"""
+		section_message = self._get_help_separator() + f"\t# {section} #\n\n"
+		for mode in list(modes.MODES[section].keys()):
+			section_message += self.__get_mode_args_and_help_str(f"\t{mode} ", mode)
+		return section_message

xmipp3_installer/application/cli/parsers/mode_help_formatter.py

@@ -0,0 +1,115 @@
+"""### Help formatter specific for non-generic usage modes."""
+
+from typing import List
+
+from xmipp3_installer.application.cli import arguments
+from xmipp3_installer.application.cli.arguments import modes, params
+from xmipp3_installer.application.cli.parsers import format
+from xmipp3_installer.application.cli.parsers.base_help_formatter import BaseHelpFormatter
+from xmipp3_installer.application.logger.logger import logger
+
+class ModeHelpFormatter(BaseHelpFormatter):
+	"""
+	### Overrides the default help formatter to display a custom help message deppending on the mode selected.
+	"""
+	def format_help(self):
+		"""
+		### This method prints the help message of the argument parser.
+		"""
+		mode = self.__get_mode()
+		help_message = f"{self._get_mode_help(mode, general=False)}\n\n"
+		help_message += self.__get_args_message(mode)
+		help_message += self.__get_examples_message(mode)
+		return format.get_formatting_tabs(help_message)
+
+	def __get_mode(self):
+		"""
+		### Returns the execution mode.
+
+		#### Returns:
+		- (str): Execution mode.
+		"""
+		# Retrieved from the parent help message
+		# Message received is the format_help output of the main parser's
+		# formatter, adding the mode at the end
+		return self._prog.split(' ')[-1]
+	
+	def __get_args_message(self, mode: str) -> str:
+		"""
+		### Returns the help section containing all the parameters.
+
+		#### Params:
+		- mode (str): Usage mode selected.
+
+		#### Returns:
+		- (str): Help section containing all parameters.
+		"""
+		args = modes.MODE_ARGS[mode]
+		help_message = ''
+		options_str = ''
+		separator = ''
+		
+		if len(args) > 0:
+			arg_names = [self._get_param_first_name(arg_name) for arg_name in args]
+			if self.__args_contain_optional(arg_names):
+				help_message += logger.yellow("Note: only params starting with '-' are optional. The rest are required.\n")
+			options_str = ' [options]'
+			separator = self._get_help_separator() + '\t# Options #\n\n'
+
+		help_message += f'Usage: {arguments.XMIPP_PROGRAM_NAME} {mode}{options_str}\n{separator}'
+		help_message += self.__get_args_info(args)
+		return help_message
+
+	def __args_contain_optional(self, arg_names: List[str]) -> bool:
+		"""
+		### Returns True if the param name list contains at least one optional param.
+
+		### Params:
+		- arg_names (list[str]): List containing the param names.
+
+		### Returns:
+		- (bool): True if there is at least one optional param. False otherwise.
+		"""
+		for name in arg_names:
+			if name.startswith('-'):
+				return True
+		return False
+
+	def __get_args_info(self, args: List[str]) -> str:
+		"""
+		### Returns the info of each param.
+
+		#### Params:
+		- args (list[str]): List of parameters.
+
+		#### Returns:
+		- (str): Info of all parameters.
+		"""
+		help_message = ''
+		for arg in args:
+			help_message += self._text_with_limits(
+				'\t' + ', '.join(format.get_param_names(arg)),
+				params.PARAMS[arg][params.DESCRIPTION]
+			)
+		return help_message
+
+	def __get_examples_message(self, mode: str) -> str:
+		"""
+		### Returns the message section containig usage examples.
+
+		#### Params:
+		- mode (str): Usage mode selected.
+
+		#### Returns:
+		- (str): Message section containing usage examples.
+		"""
+		help_message = ''
+		examples = modes.MODE_EXAMPLES[mode]
+		for i in range(len(examples)):
+			number_str = '' if len(examples) == 1 else f' {i+1}'	
+			help_message += f"\nExample{number_str}: {examples[i]}"
+		
+		if len(examples) > 0:
+			help_message += '\n'
+
+		return help_message

xmipp3_installer/application/logger/errors.py

@@ -0,0 +1,28 @@
+"""### Contains all constants needed for handling errors during Xmipp's installation."""
+
+from xmipp3_installer.installer.urls import CMAKE_INSTALL_DOCS_URL
+from xmipp3_installer.installer.constants import paths
+
+# Error codes
+INTERRUPTED_ERROR = -1
+OK = 0
+UNKOW_ERROR = 1
+SOURCE_CLONE_ERROR = 2
+CMAKE_ERROR = 3
+CMAKE_CONFIGURE_ERROR = 4
+CMAKE_COMPILE_ERROR = 5
+CMAKE_INSTALL_ERROR = 6
+IO_ERROR = 7
+
+# Error messages
+__CHECK_LOG_MESSAGE = f'Check the inside file \'{paths.LOG_FILE}\'.'
+ERROR_CODES = {
+	INTERRUPTED_ERROR: ['Process was interrupted by the user.', ''],
+	UNKOW_ERROR: ['', ''],
+	SOURCE_CLONE_ERROR: ['Error cloning xmipp repository with git.', 'Please review the internet connection and the git package.'],
+	CMAKE_ERROR: ['There was an error with CMake.', f'Please install it by following the instructions at {CMAKE_INSTALL_DOCS_URL}'],
+	CMAKE_CONFIGURE_ERROR: ['Error configuring with CMake.', __CHECK_LOG_MESSAGE],
+	CMAKE_COMPILE_ERROR: ['Error compiling with CMake.', __CHECK_LOG_MESSAGE],
+	CMAKE_INSTALL_ERROR: ['Error installing with CMake.', __CHECK_LOG_MESSAGE],
+	IO_ERROR: ['Input/output error.', 'This error can be caused by the installer not being able to read/write/create/delete a file. Check your permissions on this directory.']
+}

xmipp3_installer/application/logger/logger.py

@@ -0,0 +1,230 @@
+"""### Provides a global logger."""
+
+import math
+import shutil
+from io import BufferedReader
+
+from xmipp3_installer.shared.singleton import Singleton
+from xmipp3_installer.application.logger import errors
+from xmipp3_installer.installer import urls
+
+class Logger(Singleton):
+	"""
+	### Logger class for keeping track of installation messages.
+	"""
+	__UP = "\x1B[1A\r"
+	__REMOVE_LINE = '\033[K'
+	__BOLD = "\033[1m"
+	__BLUE = "\033[34m"
+	__RED = "\033[91m"
+	__GREEN = "\033[92m"
+	__YELLOW = "\033[93m"
+	__END_FORMAT = "\033[0m"
+	__FORMATTING_CHARACTERS = [__UP, __REMOVE_LINE, __BOLD, __BLUE, __RED, __GREEN, __YELLOW, __END_FORMAT]
+ 
+	def __init__(self):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- ouputToConsoloe (bool): Print messages to console.
+		"""
+		self.__log_file = None
+		self.__len_last_printed_elem = 0
+		self.__allow_substitution = True
+	
+	def green(self, text: str) -> str:
+		"""
+		### This function returns the given text formatted in green color.
+
+		#### Params:
+		- text (str): Text to format.
+
+		#### Returns:
+		- (str): Text formatted in green color.
+		"""
+		return self.__format_text(text, self.__GREEN)
+
+	def yellow(self, text: str) -> str:
+		"""
+		### This function returns the given text formatted in yellow color.
+
+		#### Params:
+		- text (str): Text to format.
+
+		#### Returns:
+		- (str): Text formatted in yellow color.
+		"""
+		return self.__format_text(text, self.__YELLOW)
+
+	def red(self, text: str) -> str:
+		"""
+		### This function returns the given text formatted in red color.
+
+		#### Params:
+		- text (str): Text to format.
+
+		#### Returns:
+		- (str): Text formatted in red color.
+		"""
+		return self.__format_text(text, self.__RED)
+
+	def blue(self, text: str) -> str:
+		"""
+		### This function returns the given text formatted in blue color.
+
+		#### Params:
+		- text (str): Text to format.
+
+		#### Returns:
+		- (str): Text formatted in blue color.
+		"""
+		return self.__format_text(text, self.__BLUE)
+
+	def bold(self, text: str) -> str:
+		"""
+		### This function returns the given text formatted in bold.
+
+		#### Params:
+		- text (str): Text to format.
+
+		#### Returns:
+		- (str): Text formatted in bold.
+		"""
+		return self.__format_text(text, self.__BOLD)
+
+	def start_log_file(self, log_path: str):
+		"""
+		### Initiates the log file.
+
+		#### Params:
+		- log_path (str): Path to the log file.
+		"""
+		if self.__log_file is None:
+			self.__log_file = open(log_path, 'w')
+
+	def close(self):
+		"""
+		### Closes the log file.
+		"""
+		if self.__log_file:
+			self.__log_file.close()
+			self.__log_file = None
+
+	def set_allow_substitution(self, allow_substitution: bool):
+		"""
+		### Modifies console output behaviour, allowing or disallowing substitutions.
+		
+		#### Params:
+		- allow_substitution (bool): If False, console outputs won't be substituted.
+		"""
+		self.__allow_substitution = allow_substitution
+
+	def __call__(self, text: str, show_in_terminal: bool=True, substitute: bool=False):
+		"""
+		### Log a message.
+		
+		#### Params:
+		- text (str): Message to be logged. Supports fancy formatting.
+		- show_in_terminal (bool): Optional. If True, text is also printed through terminal.
+		- substitute (bool): Optional. If True, previous line is substituted with new text. Only used when show_in_terminal = True.
+		"""
+		if self.__log_file is not None:
+			print(self.__remove_non_printable(text), file=self.__log_file, flush=True)
+			
+		if show_in_terminal:
+			text = self.__substitute_lines(text) if self.__allow_substitution and substitute else text
+			print(text, flush=True)
+			# Store length of printed string for next substitution calculation
+			self.__len_last_printed_elem = len(self.__remove_non_printable(text))
+	 
+	def log_error(self, error_msg: str, ret_code: int=1, add_portal_link: bool=True):
+		"""
+		### Prints an error message.
+
+		#### Params:
+		- error_msg (str): Error message to show.
+		- ret_code (int): Optional. Return code to end the exection with.
+		- add_portal_link (bool): If True, a message linking the documentation portal is shown.
+		"""
+		error = errors.ERROR_CODES.get(ret_code, errors.ERROR_CODES[errors.UNKOW_ERROR])
+		error_str = error_msg + '\n\n' if error_msg else ''
+		error_str += f'Error {ret_code}: {error[0]}'
+		error_str += f"\n{error[1]}" if error[1] else ''
+		if add_portal_link:
+			error_str += f'\nMore details on the Xmipp documentation portal: {urls.DOCUMENTATION_URL}'
+
+		self.__call__(self.red(error_str), show_in_terminal=True)
+
+	def log_in_streaming(self, stream: BufferedReader, show_in_terminal: bool=False, substitute: bool=False, err: bool=False):
+		"""
+		### Receives a process output stream and logs its lines.
+
+		#### Params:
+		- stream (BufferedReader): Function to run.
+		- show_in_terminal (bool): Optional. If True, output will also be printed through terminal.
+		- substitute (bool): Optional. If True, output will replace previous line. Only used when show is True.
+		- err (bool): Optional. If True, the stream contains an error. Otherwise, it is regular output.
+		"""
+		if show_in_terminal and self.__allow_substitution and substitute:
+			print("")
+		
+		for line in iter(stream.readline, b''):
+			line = line.decode().replace("\n", "")
+			if err:
+				line = self.red(line)
+			self.__call__(line, show_in_terminal=show_in_terminal, substitute=substitute)
+
+	def __remove_non_printable(self, text: str) -> str:
+		"""
+		### This function returns the given text without non printable characters.
+
+		#### Params:
+		- text (str): Text to remove format.
+
+		#### Returns:
+		- (str): Text without format.
+		"""
+		for formatting_char in self.__FORMATTING_CHARACTERS:
+			text = text.replace(formatting_char, "")
+		return text
+
+	def __get_n_last_lines(self) -> int:
+		"""
+		### This function returns the number of lines of the terminal the last print occupied.
+
+		#### Returns:
+		- (int): Number of lines of the last print. 
+		"""
+		return math.ceil(self.__len_last_printed_elem / shutil.get_terminal_size().columns)
+	
+	def __format_text(self, text: str, format_code: str) -> str:
+		"""
+		### Returns the given text formatted in the given format code.
+
+		#### Params:
+		- text (str): Text to format.
+		- format_code (str): Formatting character.
+
+		#### Returns:
+		- (str): Text formatted.
+		"""
+		return f"{format_code}{text}{self.__END_FORMAT}"
+
+	def __substitute_lines(self, text: str) -> str:
+		"""
+		### Removes the appropiate lines from the terminal to show a given text.
+
+		#### Params:
+		- text (str): Text to show substituting some lines.
+
+		#### Returns:
+		- (str): Text with line substitution characters as a prefix.
+		"""
+		substitution_chars = [f'{self.__UP}{self.__REMOVE_LINE}' for _ in range(self.__get_n_last_lines())]
+		return f"{''.join(substitution_chars)}{text}"
+	
+"""
+### Global logger.
+"""
+logger = Logger()

xmipp3_installer/application/logger/predefined_messages.py

@@ -0,0 +1,66 @@
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer.handlers import git_handler
+
+__SECTION_MESSAGE_LEN = 60
+
+def get_done_message() -> str:
+  """
+  ### Returns the standard message string to use when a task is completed.
+
+  #### Returns:
+  - (str): Task completion message.
+  """
+  return logger.green("Done")
+
+def get_working_message() -> str:
+  """
+  ### Returns the standard message string to use when a task is in progress.
+
+  #### Returns:
+  - (str): Task in progress message.
+  """
+  return logger.yellow("Working...")
+
+def get_section_message(text: str) -> str:
+	"""
+	### Returns the given text as a section header.
+
+	#### Params:
+	- text (str): Title of the section.
+
+	#### Returns:
+	- (str): Formatted section header.
+	"""
+	text_len = len(text)
+	remaining_len = __SECTION_MESSAGE_LEN - text_len
+	if remaining_len < 4:
+		return text
+	
+	n_dashes = remaining_len - 2
+	n_final_dashes = int(n_dashes / 2)
+	n_initial_dashes = n_dashes - n_final_dashes
+	final_dashes = ''.join(['-' for _ in range(n_final_dashes)])
+	initial_dashes = ''.join(['-' for _ in range(n_initial_dashes)])
+	return f"{initial_dashes} {text} {final_dashes}"
+
+def get_success_message(tag_version: str) -> str:
+	"""
+	### Returns the message shown when Xmipp is compiled successfully.
+
+	#### Params:
+	- tag_version (str): Version number of the latest release.
+	
+	#### Returms:
+	- (str): Success message.
+	"""
+	release_name = tag_version if git_handler.is_tag() else git_handler.get_current_branch()
+
+	box_wrapper = '*  *'
+	half_len_box_wrapper = int(len(box_wrapper) / 2)
+	release_message = f'Xmipp {release_name} has been successfully installed, enjoy it!'
+	total_len = len(release_message) + len(box_wrapper)
+	release_message = f'{box_wrapper[:half_len_box_wrapper]}{logger.green(release_message)}{box_wrapper[half_len_box_wrapper:]}'
+	margin_line = f"*{' ' * (total_len - 2)}*"
+	box_border = '*' * total_len
+
+	return '\n'.join(["", box_border, margin_line, release_message, margin_line, box_border])

xmipp3_installer/application/user_interactions.py

@@ -0,0 +1,16 @@
+def get_user_confirmation(confirmation_text: str, case_sensitive: bool=True) -> bool:
+  """
+  ### Receives confirmation from user input.
+
+  #### Params:
+  - confirmation_text (str): The text the user needs to input to confirm.
+  - case_sensitive (bool): Optional. If True, the text entered has to exactly match.
+
+  #### Returns:
+  - (bool): True if the user confirmed, False otherwise.
+  """
+  received_input = input()
+  if not case_sensitive:
+    received_input = received_input.lower()
+    confirmation_text = confirmation_text.lower()
+  return received_input == confirmation_text

xmipp3_installer/installer/__init__.py

@@ -0,0 +1 @@
+"""### Contains the main logic of the project."""

xmipp3_installer/installer/constants/__init__.py

@@ -0,0 +1,17 @@
+"""### Contains constants used to configure the installer."""
+
+# Repository names
+XMIPP = 'xmipp'
+XMIPP_CORE = 'xmippCore'
+XMIPP_VIZ = 'xmippViz'
+XMIPP_SOURCES = [XMIPP_CORE, XMIPP_VIZ]
+
+# Branch names
+DEVEL_BRANCHNAME = 'devel'
+MASTER_BRANCHNAME = 'master'
+
+# Context
+VERSIONS_CONTEXT_KEY = "versions"
+
+# Others
+TAIL_LOG_NCHARS = 300

xmipp3_installer/installer/constants/paths.py

@@ -0,0 +1,32 @@
+import os
+
+from xmipp3_installer.installer import constants
+
+# General paths
+SOURCES_PATH = "src"
+BUILD_PATH = "build"
+INSTALL_PATH = "dist"
+BINARIES_PATH = os.path.join(INSTALL_PATH, "bin")
+#CMAKE_CACHE_PATH = os.path.join(BUILD_PATH, 'CMakeCache.txt')
+SCIPION_SOFTWARE_EM = os.path.join("scipionfiles", "downloads", "scipion", "software", "em")
+
+# General file paths
+LOG_FILE = 'compilation.log'
+LIBRARY_VERSIONS_FILE = os.path.join(BUILD_PATH, 'versions.txt')
+CONFIG_FILE = 'xmipp.conf'
+VERSION_INFO_FILE = "version-info.json"
+
+# Source paths
+def get_source_path(source: str) -> str:
+  """
+  ### Returns the path to the given source.
+
+  #### Params:
+  - source (str): Source name.
+
+  #### Returns:
+  - (str): Path to the source.
+  """
+  return os.path.abspath(os.path.join(SOURCES_PATH, source))
+XMIPP_CORE_PATH = get_source_path(constants.XMIPP_CORE)
+XMIPP_SOURCE_PATHS = [get_source_path(source) for source in constants.XMIPP_SOURCES]

xmipp3_installer/installer/handlers/__init__.py

@@ -0,0 +1 @@
+"""### Contains the handlers, providing interfaces to interact with different systems."""

xmipp3_installer/installer/handlers/cmake/__init__.py

@@ -0,0 +1 @@
+"""### Contains CMake handler & different related constants."""

xmipp3_installer/installer/handlers/cmake/cmake_constants.py

@@ -0,0 +1,27 @@
+"""### Contains all needed CMake constants."""
+
+from xmipp3_installer.repository.config_vars import variables
+
+DEFAULT_CMAKE = 'cmake'
+
+# CMake cache file variables to look for
+XMIPP_USE_CUDA=variables.CUDA
+XMIPP_USE_MPI=variables.MPI
+XMIPP_USE_MATLAB=variables.MATLAB
+XMIPP_LINK_TO_SCIPION=variables.LINK_SCIPION
+CMAKE_BUILD_TYPE='CMAKE_BUILD_TYPE'
+CMAKE_C_COMPILER=variables.CC
+CMAKE_CXX_COMPILER=variables.CXX
+CMAKE_CUDA_COMPILER=variables.CUDA_COMPILER
+
+# CMake saved version variables
+CMAKE_PYTHON = 'Python3'
+CMAKE_CUDA = 'CUDA'
+CMAKE_MPI = 'MPI'
+CMAKE_HDF5 = 'HDF5'
+CMAKE_JPEG = 'JPEG'
+CMAKE_SQLITE = 'SQLite3'
+CMAKE_JAVA = 'Java'
+CMAKE_CMAKE = 'CMake'
+CMAKE_GCC = 'CC'
+CMAKE_GPP = 'CXX'