xmipp3-installer 1.0.0__py3-none-any.whl

xmipp3_installer/application/cli/cli.py

@@ -0,0 +1,271 @@
+"""### Command Line Interface that interacts with the installer."""
+
+import argparse
+import multiprocessing
+import os
+import sys
+from typing import Dict, Any
+
+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.error_handler_parser import ErrorHandlerArgumentParser
+from xmipp3_installer.application.cli.parsers.general_help_formatter import GeneralHelpFormatter
+from xmipp3_installer.application.cli.parsers.mode_help_formatter import ModeHelpFormatter
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.installer import installer_service
+
+def main():
+	"""### Main entry point function that starts the execution."""
+	parser = __generate_parser()
+	parser = __add_params(parser)
+	__add_default_usage_mode()
+	args = vars(parser.parse_args())
+	__validate_args(args, parser)
+	installation_manager = installer_service.InstallationManager(args)
+	ret_code = installation_manager.run_installer()
+	sys.exit(ret_code)
+
+def __generate_parser() -> argparse.ArgumentParser:
+	"""
+	### Generates an argument parser for the installer.
+
+	#### Returns:
+	- (ArgumentParser): Argument parser.
+	"""
+	return ErrorHandlerArgumentParser(
+		prog=arguments.XMIPP_PROGRAM_NAME,
+		formatter_class=GeneralHelpFormatter,
+	)
+
+def __add_params(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+	"""
+	### Inserts the params into the given parser.
+
+	#### Params:
+	- parser (ArgumentParser): Argument parser.
+
+	#### Returns:
+	- (ArgumentParser): Argument parser with inserted params.
+	"""
+	subparsers = parser.add_subparsers(dest=modes.MODE)
+	default_jobs = __get_default_job_number()
+
+	add_model_subparser = subparsers.add_parser(modes.MODE_ADD_MODEL, formatter_class=ModeHelpFormatter)
+	__add_params_mode_add_model(add_model_subparser)
+
+	all_subparser = subparsers.add_parser(modes.MODE_ALL, formatter_class=ModeHelpFormatter)
+	__add_params_mode_all(all_subparser, default_jobs)
+
+	subparsers.add_parser(modes.MODE_CLEAN_ALL, formatter_class=ModeHelpFormatter)
+
+	subparsers.add_parser(modes.MODE_CLEAN_BIN, formatter_class=ModeHelpFormatter)
+
+	compile_and_install_subparser = subparsers.add_parser(modes.MODE_COMPILE_AND_INSTALL, formatter_class=ModeHelpFormatter)
+	__add_params_mode_compile_and_install(compile_and_install_subparser, default_jobs)
+
+	build_config_subparser = subparsers.add_parser(modes.MODE_CONFIG_BUILD, formatter_class=ModeHelpFormatter)
+	__add_params_mode_config_build(build_config_subparser)
+
+	config_subparser = subparsers.add_parser(modes.MODE_CONFIG, formatter_class=ModeHelpFormatter)
+	__add_params_mode_config(config_subparser)
+
+	get_models_subparser = subparsers.add_parser(modes.MODE_GET_MODELS, formatter_class=ModeHelpFormatter)
+	__add_params_mode_get_models(get_models_subparser)
+
+	get_sources_subparser = subparsers.add_parser(modes.MODE_GET_SOURCES, formatter_class=ModeHelpFormatter)
+	__add_params_mode_get_sources(get_sources_subparser)
+
+	git_subparser = subparsers.add_parser(modes.MODE_GIT, formatter_class=ModeHelpFormatter)
+	__add_params_mode_git(git_subparser)
+
+	test_subparser = subparsers.add_parser(modes.MODE_TEST, formatter_class=ModeHelpFormatter)
+	__add_params_mode_test(test_subparser)
+
+	version_subparser = subparsers.add_parser(modes.MODE_VERSION, formatter_class=ModeHelpFormatter)
+	__add_params_mode_version(version_subparser)
+
+	return parser
+
+def __add_params_mode_add_model(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "addModel"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_LOGIN))
+	subparser.add_argument(*format.get_param_names(params.PARAM_MODEL_PATH))
+	subparser.add_argument(*format.get_param_names(params.PARAM_UPDATE), action='store_true')
+
+def __add_params_mode_all(subparser: argparse.ArgumentParser, default_jobs: int):
+	"""
+	### Adds params for mode "all"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	- default_jobs (int): Default number of jobs to run the task.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_JOBS), type=int, default=default_jobs)
+	subparser.add_argument(*format.get_param_names(params.PARAM_BRANCH))
+	subparser.add_argument(*format.get_param_names(params.PARAM_KEEP_OUTPUT), action='store_true')
+
+def __add_params_mode_compile_and_install(subparser: argparse.ArgumentParser, default_jobs: int):
+	"""
+	### Adds params for mode "compileAndInstall"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	- default_jobs (int): Default number of jobs to run the task.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_JOBS), type=int, default=default_jobs)
+	subparser.add_argument(*format.get_param_names(params.PARAM_BRANCH))
+	subparser.add_argument(*format.get_param_names(params.PARAM_KEEP_OUTPUT), action='store_true')
+
+def __add_params_mode_config_build(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "configBuild"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_KEEP_OUTPUT), action='store_true')
+
+def __add_params_mode_config(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "config"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_OVERWRITE), action='store_true')
+
+def __add_params_mode_get_models(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "getModels"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(
+		*format.get_param_names(params.PARAM_MODELS_DIRECTORY),
+		default=__get_project_root_subpath(arguments.DEFAULT_MODELS_DIR)
+	)
+
+def __add_params_mode_get_sources(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "getSources"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_BRANCH))
+	subparser.add_argument(*format.get_param_names(params.PARAM_KEEP_OUTPUT), action='store_true')
+
+def __add_params_mode_git(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "git"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_GIT_COMMAND), nargs='+')
+
+def __add_params_mode_test(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "test"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_TEST_NAMES), nargs='*', default=None)
+	subparser.add_argument(*format.get_param_names(params.PARAM_SHOW_TESTS), action='store_true')
+
+def __add_params_mode_version(subparser: argparse.ArgumentParser):
+	"""
+	### Adds params for mode "version"
+
+	#### Params:
+	- subparser (ArgumentParser): Subparser to add the params to.
+	"""
+	subparser.add_argument(*format.get_param_names(params.PARAM_SHORT), action='store_true')
+
+def __get_default_job_number() -> int:
+	"""
+	### Gets the default number of jobs to be used by parallelizable tasks.
+	Returned number will be 120% of CPU cores, due to not all jobs taking 
+	100% of CPU time continuously.
+
+	#### Returns:
+	- (int): Default number of jobs.
+	"""
+	return multiprocessing.cpu_count() + int(multiprocessing.cpu_count() * 0.2)
+
+def __get_project_root_subpath(subpath: str) -> str:
+	"""
+	### Returns a subpath of Xmipp's root directory.
+
+	#### Params:
+	- subpath (str): Subpath inside the root directory.
+
+	#### Returns:
+	- (str): Absolute path to given subpath.
+	"""
+	return os.path.join(__get_project_root_dir(), subpath)
+
+def __get_project_root_dir() -> str:
+	"""
+	### Returns the root directory of Xmipp.
+
+	#### Returns:
+	- (str): Absolute path to Xmipp's root directory.
+	"""
+	return os.path.dirname(os.path.abspath(__file__))
+
+def __add_default_usage_mode():
+	"""
+	### Sets the usage mode as the default one when a mode has not been specifically provided.
+	"""
+	no_args_provided = len(sys.argv) == 1
+	args_provided = len(sys.argv) > 1
+	if no_args_provided or (
+		args_provided and __is_first_arg_optional() and not __help_requested()
+		): 
+		sys.argv.insert(1, modes.MODE_ALL)
+
+def __is_first_arg_optional() -> bool:
+	"""
+	### Returns True if the first argument provided is optional.
+
+	#### Returns:
+	- (bool): True if the first argument received is optional.
+	"""
+	return sys.argv[1].startswith('-')
+
+def __help_requested() -> bool:
+	"""
+	### Returns True if help is at least one of the args.
+
+	#### Returns:
+	- (bool): True if help is at least one of the args.
+	"""
+	return '-h' in sys.argv or '--help' in sys.argv
+
+def __validate_args(args: Dict[str, Any], parser: argparse.ArgumentParser):
+	"""
+	### Performs validations on the arguments.
+
+	#### Params:
+	- args (dict(str, any)): Arguments to be validated.
+	- parser (ArgumentParser): Argument parser.
+	"""
+	jobs = args.get('jobs', 1)
+	if jobs < 1:
+		parser.error(f"Wrong job number \"{jobs}\". Number of jobs has to be 1 or greater.")
+	
+	branch = args.get('branch')
+	if branch is not None and len(branch.split(' ')) > 1:
+		parser.error(f"Incorrect branch name \"{branch}\". Branch names can only be one word long.")
+	
+	if args.get('keep_output', False):
+		logger.set_allow_substitution(False)

xmipp3_installer/application/cli/parsers/base_help_formatter.py

@@ -0,0 +1,244 @@
+"""### Defines a base help formatter with extened functions to be used by the custom formatters."""
+
+import argparse
+import shutil
+from typing import List, Tuple
+
+from xmipp3_installer.application.cli.arguments import modes, params
+from xmipp3_installer.application.cli.parsers import format
+
+class BaseHelpFormatter(argparse.HelpFormatter):
+	"""
+	### Extendes the available functions of the generic help formatter.
+	"""
+	__SECTION_N_DASH = 45
+	__SECTION_SPACE_MODE_HELP = 2
+	__SECTION_HELP_START = format.TAB_SIZE + __SECTION_N_DASH + __SECTION_SPACE_MODE_HELP
+	__LINE_SIZE_LOWER_LIMIT = int(__SECTION_HELP_START * 1.5)
+
+	def _get_mode_help(self, mode: str, general: bool=True) -> str:
+		"""
+		### Returns the help message of a given mode.
+
+		### Params:
+		- mode (str): Mode to get help text for.
+		- general (bool). Optional. If True, only the general help message is displayed.
+
+		### Returns:
+		- (str): Help of the mode (empty if mode not found).
+		"""
+		for group in list(modes.MODES.keys()):
+			if mode in list(modes.MODES[group].keys()):
+				messages = modes.MODES[group][mode]
+				return self.__get_message_from_list(messages, general)
+		return ''
+	
+	def _get_param_first_name(self, param_key: str) -> str:
+		"""
+		### Returns the first name of the given param key. Short name has priority over long name.
+
+		### Params:
+		- param_key (str): Key to identify the param.
+
+		### Returns:
+		- (str): Formatted text.
+		"""
+		param = params.PARAMS[param_key]
+		return param.get(params.SHORT_VERSION, param.get(params.LONG_VERSION, ''))
+
+	def _get_help_separator(self) -> str:
+		"""
+		### Returns the line that separates sections inside the help message.
+
+		### Returns:
+		- (str): Line that separates sections inside the help message.
+		"""
+		dashes = ['-' for _ in range(self.__SECTION_N_DASH)]
+		return format.get_formatting_tabs(f"\t{''.join(dashes)}\n")
+
+	def _text_with_limits(self, previous_text: str, text: str) -> str:
+		"""
+		### Returns the given text, formatted so that it does not exceed the character limit by line for the param help section.
+
+		### Params:
+		- previous_text (str): Text inserted before the one to be returned.
+		- text (str): The text to be formatted.
+
+		### Returns:
+		- (str): Formatted text.
+		"""
+		remaining_space, fill_in_space = self.__get_spaces(previous_text)
+		formatted_help = self.__multi_line_help_text(
+			text,
+			remaining_space,
+			self.__get_start_section_fill_in_space('')
+		)
+		return f"{previous_text}{fill_in_space}{formatted_help}\n"
+
+	def _get_text_length(self, text: str) -> int:
+		"""
+		### Returns the length of a text that might contain tabs.
+
+		#### Params:
+		- text (str): Text to measure.
+
+		#### Returns:
+		- (int): Text's length.
+		"""
+		return len(format.get_formatting_tabs(text))
+
+	def __get_message_from_list(self, messages: List[str], only_general: bool) -> str:
+		"""
+		### Return the appropiate message given a list of them and a condition.
+
+		#### Params:
+		- messages (list[str]): List of messages.
+		- only_general (bool): If True, only the general (first) message is returned.
+
+		#### Returns:
+		- (str): Expected messages in a string.
+		"""
+		return messages[0] if only_general else '\n'.join(messages)
+
+	def __get_line_size(self) -> int:
+		"""
+		### Returns the maximum size for a line.
+
+		### Returns:
+		- (int): Maximum line size.
+		"""
+		size = shutil.get_terminal_size().columns
+		return self.__LINE_SIZE_LOWER_LIMIT if size < self.__LINE_SIZE_LOWER_LIMIT else size
+
+	def __multi_line_help_text(self, text: str, size_limit: int, left_fill: str) -> str:
+		"""
+		### This function returns the given text, formatted in several lines so that it does not exceed the given character limit.
+
+		### Params:
+		- text (str): The text to be formatted.
+		- size_limit (int): Size limit for the text.
+		- left_fill (str): String to add at the left of each new line.
+
+		### Returns:
+		- (str): Formatted text.
+		"""
+		return (
+			text
+			if len(text) <= size_limit else
+			self.__format_text_in_lines(text, size_limit, left_fill)
+		)
+
+	def __fit_words_in_line(self, words: List[str], size_limit: int) -> Tuple[str, List[str]]:
+		"""
+		### Returns a tuple containig a line with the words from the given list that could fit given the size limit, and the list with the remaining words.
+
+		### Params:
+		- words (list[str]): List of words to try to fit into a line.
+		- size_limit (int): Size limit for the text.
+
+		### Returns:
+		- (str): Line with the words that were able to fit in it.
+		- (list[str]): List containing the words that could not fit in the line.
+		"""
+		line = ''
+		remaining_words = words
+		for word in words:
+			if self.__word_fits_in_line(line, word, size_limit):
+				line, remaining_words = self.__add_word_to_line(line, word, remaining_words)
+			else:
+				break
+		return line, remaining_words
+				
+	def __word_fits_in_line(self, line: str, word: str, size_limit: int) -> bool:
+		"""
+		### Checks if a word can fit in the current line without exceeding the size limit.
+
+		### Params:
+		- line (str): The current line of text.
+		- word (str): The word to check.
+		- size_limit (int): The maximum allowed size for the line.
+
+		### Returns:
+		- (bool): True if the word fits in the line, False otherwise.
+		"""
+		if line:
+			return len(f"{line} {word}") <= size_limit
+		return len(word) <= size_limit
+
+	def __add_word_to_line(self, line: str, word: str, remaining_words: List[str]) -> Tuple[str, List[str]]:
+		"""
+		### Adds a word to the current line and updates the list of remaining words.
+
+		### Params:
+		- line (str): The current line of text.
+		- word (str): The word to add to the line.
+		- remaining_words (list[str]): The list of words yet to be added to the line.
+
+		### Returns:
+		- (str): The updated line with the new word added.
+		- (list[str]): The updated list of remaining words.
+		"""
+		if line:
+			line += f" {word}"
+		else:
+			line = word
+		return line, remaining_words[1:]
+
+	def __format_text_in_lines(self, text: str, size_limit: int, left_fill: str):
+		"""
+		### Returns the text formatted into size-limited lines.
+
+		#### Params:
+		- text (str): Text to format.
+		- size_limit (int): Max number of characters allowed in a single line.
+		- left_fill (str): Starting characters of each line.
+
+		#### Returns:
+		- (str): Text formatted into lines.
+		"""
+		words = text.split(' ')
+		lines = []
+		while words:
+			iteration_size_limit = size_limit if size_limit >= len(words[0]) else len(words[0])
+			line, words = self.__fit_words_in_line(words, iteration_size_limit)
+			line = left_fill + line if lines else line
+			lines.append(line)
+		return '\n'.join(lines)
+
+	def __get_spaces(self, start_section_text: str) -> Tuple[str, str]:
+		if self.__is_start_section_text_exceeding_size_limit(start_section_text):
+			# If text exceeds size limit, it means that section space for modes and params 
+			# is too low and should be set to a higher number, but for now we need to print anyways, 
+			# so we reduce space from the one reserved for mode help and add minimum fill-in space
+			remaining_space = self.__get_line_size() - self._get_text_length(start_section_text)
+			fill_in_space = ' '
+		else:
+			remaining_space = self.__get_line_size() - self.__SECTION_HELP_START
+			fill_in_space = self.__get_start_section_fill_in_space(start_section_text)
+		return remaining_space, fill_in_space
+
+	def __get_start_section_fill_in_space(self, text: str) -> str:
+		"""
+		### Returns the fill-in space for the start section.
+
+		#### Params:
+		- text (str): Text inside the start section.
+
+		#### Returns:
+		- (str): The required number of spaces to generate the start section's fill-in.
+		"""
+		return ''.join(
+			[' ' for _ in range(self.__SECTION_HELP_START - self._get_text_length(text))]
+		)
+	
+	def __is_start_section_text_exceeding_size_limit(self, start_section_text: str) -> bool:
+		"""
+		### Indicates if the given start section text exceedes allowed size limit.
+
+		#### Params:
+		- start_section_text (str): Text to measure.
+
+		#### Returns:
+		- (bool): True if the text exceedes allowed size limit.
+		"""
+		return self._get_text_length(start_section_text) >= self.__SECTION_HELP_START

xmipp3_installer/application/cli/parsers/error_handler_parser.py

@@ -0,0 +1,68 @@
+"""### Argparser that shows the error messages formatted in a custom way."""
+
+import argparse
+from typing import List
+
+from xmipp3_installer.application.cli.parsers import format
+from xmipp3_installer.application.logger.logger import logger
+
+class ErrorHandlerArgumentParser(argparse.ArgumentParser):
+	"""
+	Overrides the error function of the standard argument parser
+	to display better error messages.
+	"""
+	def error(self, message):
+		"""
+		### Prints through stderr the error message and exits with specific return code.
+		
+		#### Params:
+		- message (str): Error message.
+		"""
+		args = self.__get_args()
+		mode = self.__get_mode(args)
+
+		if self.__is_mode_generic(args):
+			args = ' '.join(args[:-1])
+			extra_line_break = '\n'
+		else:
+			args = self.format_help()
+			extra_line_break = ''
+
+		error_message = logger.red(f"{mode}: error: {message}\n")
+		self.exit(
+			1,
+			format.get_formatting_tabs(f"{args}{extra_line_break}{error_message}")
+		)
+	
+	def __get_args(self) -> List[str]:
+		"""
+		### Obtains args from stored class data.
+
+		#### Returns:
+		- (list[str]): List of arguments.
+		"""
+		return self.prog.split(' ')
+	
+	def __get_mode(self, args: List[str]) -> str:
+		"""
+		### Obtains the usage mode from the received args.
+
+		#### Params:
+		- args (list[str]): List of args received by the parser.
+		
+		#### Returns:
+		- (str): Usage mode.
+		"""
+		return args[-1]
+	
+	def __is_mode_generic(self, args: List[str]) -> bool:
+		"""
+		### Returns True if the usage mode selected is the generic one.
+
+		#### Params:
+		- args (list[str]): List of received args.
+
+		#### Returns:
+		- (bool): True if the received mode is the generic one.
+		"""
+		return len(args) > 1

xmipp3_installer/application/cli/parsers/format.py

@@ -0,0 +1,35 @@
+"""### Common formatting functions for parsers."""
+
+from typing import List
+
+from xmipp3_installer.application.cli.arguments import params
+
+TAB_SIZE = 4
+
+def get_formatting_tabs(text: str) -> str:
+	"""
+	### Returns the given text, formatted to expand tabs into a fixed tab size.
+
+	### Params:
+	- text (str): The text to be formatted.
+
+	### Returns:
+	- (str): Formatted text.
+	"""
+	return text.expandtabs(TAB_SIZE)
+
+def get_param_names(param_key: str) -> List[str]:
+	"""
+	### Returns the list of possible names a given param has.
+
+	#### Params:
+	- param_key (str): Key to find the param.
+
+	#### Returns:
+	- (list[str]): Names of the given param.
+	"""
+	names = [
+		params.PARAMS[param_key].get(params.SHORT_VERSION, ''),
+		params.PARAMS[param_key].get(params.LONG_VERSION, '')
+	]
+	return [name for name in names if name]