xmipp3-installer 1.0.0__py3-none-any.whl

xmipp3_installer/repository/config.py

@@ -0,0 +1,241 @@
+"""### Contains the configuration file singleton that interact with the configuration file."""
+
+import re
+import os
+from datetime import datetime
+from typing import List, Optional, Tuple, Dict, Any
+
+from xmipp3_installer.shared.singleton import Singleton
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.repository.config_vars import default_values, variables, config_values_adapter
+from xmipp3_installer.repository.invalid_config_line import InvalidConfigLineError
+
+class ConfigurationFileHandler(Singleton):
+	"""
+	### Configuration file class for loading and storing the installation configuration.
+	"""
+	__COMMENT_ESCAPE = '#'
+	__ASSIGNMENT_SEPARATOR = '='
+	__LAST_MODIFIED_TEXT = "Config file automatically generated on"
+
+	def __init__(self, path: str=paths.CONFIG_FILE, show_errors: bool=True):
+		"""
+		### Constructor.
+		
+		#### Params:
+		- path (str): Optional. Path to the configuration file.
+		"""
+		self.__path = path
+		self.show_errors = show_errors
+		self.values = {}
+		self.read_config()
+		self.last_modified = self.__read_config_date()
+
+	def read_config(self):
+		"""
+		### Reads the config file and stores a dictionary with all the parsed variables.
+		"""
+		file_lines = self.__get_file_content()
+		result = {}
+		for line_number, line in enumerate(file_lines):
+			new_result = self.__add_line_values(result.copy(), line, line_number + 1)
+			if new_result is None:
+				result = {}
+				break
+			result = new_result
+		self.values = {
+			**config_values_adapter.get_context_values_from_file_values(
+				default_values.CONFIG_DEFAULT_VALUES
+			),
+			**config_values_adapter.get_context_values_from_file_values(
+				result,
+				show_warnings=self.show_errors
+			)
+		}
+
+	def write_config(self, overwrite: bool=False):
+		"""
+		### Writes a template config file with stored variables, leaving the rest with default values.
+
+		#### Params:
+		- overwrite (bool): Optional. If True, default values are written, overwriting the existing file.
+		"""
+		if overwrite:
+			self.values = default_values.CONFIG_DEFAULT_VALUES
+		values = config_values_adapter.get_file_values_from_context_values(self.values.copy())
+		self.last_modified = datetime.today().strftime('%d-%m-%Y %H:%M.%S')
+		
+		lines = ["##### TOGGLE SECTION #####\n"]
+		lines.append(f"# Activate or deactivate this features using values {default_values.ON}/{default_values.OFF}\n")
+		lines.extend(self.__get_section_lines(variables.TOGGLES, values))
+
+		lines.append("\n##### PACKAGE HOME SECTION #####\n")
+		lines.append("# Use this variables to use custom installation paths for the required packages.\n")
+		lines.append("# If left empty, CMake will search for those packages within your system.\n")
+		lines.extend(self.__get_section_lines(variables.LOCATIONS, values))
+		
+		lines.append("\n##### COMPILATION FLAGS #####\n")
+		lines.append("# We recommend not modifying this variables unless you know what you are doing.\n")
+		lines.extend(self.__get_section_lines(variables.COMPILATION_FLAGS, values))
+		
+		if values:
+			lines.append("\n##### UNKNOWN VARIABLES #####\n")
+			lines.append("# This variables were not expected, but are kept here in case they might be needed.\n")
+			lines.extend(self.__get_unkown_variable_lines(values))
+
+		lines.append(f"\n# {self.__LAST_MODIFIED_TEXT} {self.last_modified}\n")
+		with open(self.__path, 'w') as config_file:
+			config_file.writelines(lines)
+
+	def get_config_date(self) -> str:
+		"""
+		### Returns the date of the last modification of the configuration file.
+
+		#### Returns:
+		- (str): Date in dd-mm-yyyy format.
+		"""
+		if not self.last_modified:
+			self.last_modified = self.__read_config_date()
+		return self.last_modified
+		
+	def __get_file_content(self) -> List[str]:
+		"""
+		### Reads the whole unparsed content of the given file.
+
+		#### Returns:
+		- (list(str)): Content of the file, where each line is a string in the result list.
+		"""
+		if not os.path.exists(self.__path):
+			return []
+		lines = []
+		with open(self.__path, "r") as config_file:
+			lines = config_file.readlines()
+		return lines
+
+	def __read_config_date(self) -> str:
+		"""
+		### Reads from the config file the date of its last modification.
+
+		#### Returns:
+		- (str): Date in dd-mm-yyyy format.
+		"""
+		config_lines = self.__get_file_content()
+		for line in config_lines:
+			if self.__LAST_MODIFIED_TEXT not in line:
+				continue
+			match = re.search(r'\d{2}-\d{2}-\d{4} \d{2}:\d{2}.\d{2}', line)
+			if match:
+				return match.group()
+		return ""
+
+	def __add_line_values(self, config: Dict, line: str, line_number: int) -> Optional[Dict]:
+		"""
+		### Adds the config values present in the current line to the given dictionary.
+
+		#### Params:
+		- config (dict): Dictionary with all the present variables.
+		- line (str): Current line to extract values from.
+		- line_number (int): Line index in the list of lines that compose the file.
+
+		#### Returns:
+		- (dict | None): An updated dictionary with the newly obtained variable, or None if there was an error.
+		"""
+		try:
+			key_value_pair = self.__parse_config_line(line, line_number)
+		except InvalidConfigLineError as error:
+			if self.show_errors:
+				logger(str(error))
+			config = {}
+			return
+		if key_value_pair:
+			key, value = key_value_pair
+			config[key] = value
+		return config
+
+	def __parse_config_line(self, line: str, line_number: int) -> Optional[Tuple[str, str]]:
+		"""
+		### Reads the given line from the config file and returns the key-value pair as a tuple.
+
+		#### Params:
+		- line_number (int): Line number inside the config file.
+		- line (str): Line to parse.
+		
+		#### Returns:
+		- (tuple(str, str) | None): Tuple containing the read key-value pair if line contains valid data.
+
+		#### Raises:
+		- RuntimeError: Raised when a line has an invalid format and cannot be parsed.
+		"""
+		line_without_comments = line.split(self.__COMMENT_ESCAPE, maxsplit=2)[0].strip()
+		if not line_without_comments:
+			return None
+		
+		tokens = line_without_comments.split(self.__ASSIGNMENT_SEPARATOR, maxsplit=1)
+		if len(tokens) != 2:
+			raise InvalidConfigLineError(
+				InvalidConfigLineError.generate_error_message(
+					paths.CONFIG_FILE,
+					line_number,
+					line
+				)
+			)
+		
+		return tokens[0].strip(), tokens[1].strip()
+
+	def __make_config_line(self, key: str, value: str, default_value: str) -> str:
+		"""
+		### Composes a config file line given a key-value pair to write.
+
+		#### Params:
+		- key (int): Name of the variable.
+		- value (str): Value of the variable found in the config file.
+		- default_value (str): Default value of the variable.
+		
+		#### Returns:
+		- (str): String containing the appropiately formatted key-value pair.
+		"""
+		default_value = '' if default_value is None else default_value
+		value = default_value if value is None else value
+		return f"{key}{self.__ASSIGNMENT_SEPARATOR}{value}" if key else ""
+
+	def __get_section_lines(self, section_type: str, config_variables: Dict[str, Any]) -> List[str]:
+		"""
+		### Returns the lines composed by the given section's variables in the dictionary, and deletes them from it.
+
+		#### Params:
+		- section_type (str): Section to extract variables from.
+		- config_variables (dict(str, any)): Dictionary containing all variables.
+
+		#### Returns:
+		- (list(str)): Config file lines created from the dictionary variables.
+		"""
+		lines = []
+		for section_variable in variables.CONFIG_VARIABLES[section_type]:
+			lines.append(''.join([
+				self.__make_config_line(
+					section_variable,
+					config_variables.get(section_variable),
+					default_values.CONFIG_DEFAULT_VALUES[section_variable]
+				),
+				"\n"
+			]))
+			config_variables.pop(section_variable, None)
+		return lines
+
+	def __get_unkown_variable_lines(self, config_variables: Dict[str, Any]) -> List[str]:
+		"""
+		### Returns the lines composed by the unkown variables in the dictionary.
+
+		#### Params:
+		- config_variables (dict(str, any)): Dictionary containing all unknown variables.
+
+		#### Returns:
+		- (list(str)): Config file lines created from the dictionary variables.
+		"""
+		lines = []
+		for variable in config_variables.keys():
+			lines.append(
+				f"{self.__make_config_line(variable, config_variables[variable], '')}\n"
+			)
+		return lines

xmipp3_installer/repository/config_vars/config_values_adapter.py

@@ -0,0 +1,107 @@
+from typing import Dict, Union
+
+from xmipp3_installer.application.logger.logger import logger
+from xmipp3_installer.repository.config_vars import variables, default_values
+
+def get_context_values_from_file_values(file_values: Dict[str, str], show_warnings: bool=True) -> Dict[str, Union[str, bool]]:
+	"""
+	### Converts configuration values from file format to context format.
+	
+	Processes a dictionary of configuration values read from file, converting toggle values 
+	from string ('ON'/'OFF') to boolean representation for use in the application context.
+
+	#### Params:
+	- file_values (dict(str, str)): Dictionary of configuration values as read from file.
+	- show_warnings (bool): Optional. If True, warning messages are shown when applicable.
+
+	#### Returns:
+	- (dict(str, str | bool)): Dictionary with values converted to their context format.
+	"""
+	context_values = {}
+	for key, value in file_values.items():
+		context_values[key] = __get_context_value_from_file_value(key, value, show_warnings)
+	return context_values
+
+def get_file_values_from_context_values(context_values: Dict[str, Union[str, bool]]) -> Dict[str, str]:
+	"""
+	### Converts configuration values from context format to file format.
+	
+	Processes a dictionary of configuration values from the application context, converting toggle values 
+	from boolean to string ('ON'/'OFF') representation for storage in configuration file.
+
+	#### Params:
+	- context_values (dict(str, str | bool)): Dictionary of configuration values from context.
+
+	#### Returns:
+	- (dict(str, str)): Dictionary with values converted to their file storage format.
+	"""
+	file_values = {}
+	for key, value in context_values.items():
+		file_values[key] = __get_file_value_from_context_value(key, value)
+	return file_values
+
+def __get_context_value_from_file_value(key: str, value: str, show_warnings: bool) -> Union[str, bool]:
+	"""
+	### Converts a single configuration value from file format to context format.
+
+	#### Params:
+	- key (str): Configuration variable key.
+	- value (str): Value as read from file.
+	- show_warnings (bool): Optional. If True, warning messages are shown when applicable.
+
+	#### Returns:
+	- (str | bool): Value converted to its context format.
+	"""
+	if key in variables.CONFIG_VARIABLES[variables.TOGGLES]:
+		return __get_boolean_value_from_string(key, value, show_warnings)
+	return value
+
+def __get_file_value_from_context_value(key: str, value: str) -> Union[str, bool]:
+	"""
+	### Converts a single configuration value from context format to file format.
+
+	#### Params:
+	- key (str): Configuration variable key.
+	- value (str | bool): Value from context.
+
+	#### Returns:
+	- (str): Value converted to its file storage format.
+	"""
+	if key in variables.CONFIG_VARIABLES[variables.TOGGLES]:
+		return __get_string_value_from_boolean(value)
+	return value
+
+def __get_boolean_value_from_string(key: str, value: str, show_warning: bool) -> bool:
+	"""
+	### Converts a toggle value from string ('ON'/'OFF') to boolean.
+
+	#### Params:
+	- key (str): Configuration variable key.
+	- value (str): String value to convert ('ON' or 'OFF').
+	- show_warnings (bool): Optional. If True, warning message is shown when applicable.
+
+	#### Returns:
+	- (bool): Boolean representation of the toggle value.
+	"""
+	if value != default_values.ON and value != default_values.OFF:
+		default_value = default_values.CONFIG_DEFAULT_VALUES[key]
+		if show_warning:
+			logger(logger.yellow(
+				f"WARNING: config variable '{key}' has unrecognized value '{value}'. "
+				f"Toggle values must be either '{default_values.ON}' or '{default_values.OFF}'. "
+				f"Default value '{default_value}' will be used instead."
+			))
+		value = default_value
+	return value == default_values.ON
+
+def __get_string_value_from_boolean(value: bool) -> str:
+	"""
+	### Converts a toggle value from boolean to string ('ON'/'OFF').
+
+	#### Params:
+	- value (bool): Boolean value to convert.
+
+	#### Returns:
+	- (str): String representation of the toggle value ('ON' or 'OFF').
+	"""
+	return default_values.ON if value else default_values.OFF

xmipp3_installer/repository/config_vars/default_values.py

@@ -0,0 +1,36 @@
+"""### Contains the default values for the config variables."""
+
+from xmipp3_installer.installer.constants import paths
+from xmipp3_installer.installer.handlers import conda_handler
+from xmipp3_installer.repository.config_vars import variables
+
+__TUNE_FLAG = '-mtune=native'
+
+ON = 'ON'
+OFF = 'OFF'
+CONFIG_DEFAULT_VALUES = {
+	variables.SEND_INSTALLATION_STATISTICS: ON,
+	variables.CMAKE: None,
+	variables.CUDA: ON,
+	variables.MPI: ON,
+	variables.CC: None,
+	variables.CXX: None,
+	variables.CMAKE_INSTALL_PREFIX: paths.INSTALL_PATH,
+	variables.CC_FLAGS: __TUNE_FLAG,
+	variables.CXX_FLAGS: __TUNE_FLAG,
+	variables.CUDA_COMPILER: None,
+	variables.PREFIX_PATH: conda_handler.get_conda_prefix_path(),
+	variables.MPI_HOME: None,
+	variables.PYTHON_HOME: None,
+	variables.FFTW_HOME: None,
+	variables.TIFF_HOME: None,
+	variables.HDF5_HOME: None,
+	variables.JPEG_HOME: None,
+	variables.SQLITE_HOME: None,
+	variables.CUDA_CXX: None,
+	variables.MATLAB: ON,
+	variables.LINK_SCIPION: ON,
+	variables.BUILD_TESTING: ON,
+ 	variables.SKIP_RPATH: ON,
+	variables.BUILD_TYPE: "Release"
+}

xmipp3_installer/repository/config_vars/variables.py

@@ -0,0 +1,48 @@
+"""### Contains all the variables related to the configuration."""
+
+SEND_INSTALLATION_STATISTICS = 'SEND_INSTALLATION_STATISTICS'
+CMAKE = 'CMAKE'
+CC = 'CMAKE_C_COMPILER'
+CXX = 'CMAKE_CXX_COMPILER'
+CC_FLAGS = 'CMAKE_C_FLAGS'
+CXX_FLAGS = 'CMAKE_CXX_FLAGS'
+CMAKE_INSTALL_PREFIX = 'CMAKE_INSTALL_PREFIX'
+CUDA = 'XMIPP_USE_CUDA'
+CUDA_COMPILER = 'CMAKE_CUDA_COMPILER'
+MPI = 'XMIPP_USE_MPI'
+PREFIX_PATH = 'CMAKE_PREFIX_PATH'
+MPI_HOME = 'MPI_HOME'
+PYTHON_HOME = 'Python3_ROOT_DIR'
+FFTW_HOME = 'FFTW_ROOT'
+TIFF_HOME = 'TIFF_ROOT'
+HDF5_HOME = 'HDF5_ROOT'
+JPEG_HOME = 'JPEG_ROOT'
+SQLITE_HOME = 'SQLite_ROOT'
+CUDA_CXX = 'CMAKE_CUDA_HOST_COMPILER'
+MATLAB = 'XMIPP_USE_MATLAB'
+LINK_SCIPION = 'XMIPP_LINK_TO_SCIPION'
+BUILD_TESTING = 'BUILD_TESTING'
+SKIP_RPATH='CMAKE_SKIP_RPATH'
+BUILD_TYPE = "BUILD_TYPE"
+
+# Not stored in ket=value format
+LAST_MODIFIED_KEY = "last_modified"
+
+# File structure
+TOGGLES = 'toggles'
+LOCATIONS = 'locations'
+COMPILATION_FLAGS = 'flags'
+CONFIG_VARIABLES = {
+	TOGGLES: [
+		SEND_INSTALLATION_STATISTICS, CUDA, MPI, MATLAB, LINK_SCIPION, BUILD_TESTING, SKIP_RPATH
+	],
+	LOCATIONS: [
+		CMAKE, CC, CXX, CMAKE_INSTALL_PREFIX, PREFIX_PATH, MPI_HOME,
+		CUDA_COMPILER, PYTHON_HOME, FFTW_HOME, TIFF_HOME, 
+	 	HDF5_HOME, JPEG_HOME, SQLITE_HOME, CUDA_CXX
+	],
+	COMPILATION_FLAGS: [CC_FLAGS, CXX_FLAGS, BUILD_TYPE]
+}
+
+# Do not pass this variables to CMake, only for installer logic
+INTERNAL_LOGIC_VARS = [SEND_INSTALLATION_STATISTICS, CMAKE, BUILD_TYPE]

xmipp3_installer/repository/invalid_config_line.py

@@ -0,0 +1,15 @@
+"""### Contains a custom exception for lines in the configuration file with invalid format."""
+
+from xmipp3_installer.application.logger.logger import logger
+
+class InvalidConfigLineError(RuntimeError):
+  @staticmethod
+  def generate_error_message(config_file, line_number, line):
+    return '\n'.join([
+      logger.yellow(f"WARNING: There was an error parsing {config_file} file: "),
+      logger.red(f'Unable to parse line {line_number}: {line}'),
+      logger.yellow(
+        "Contents of config file won't be read, default values will be used instead.\n"
+        f"You can create a new file template from scratch deleting file {config_file} and trying again."
+      )
+    ])

xmipp3_installer/shared/file_operations.py

@@ -0,0 +1,18 @@
+import os
+import shutil
+from typing import List
+
+def delete_paths(paths: List[str]):
+	"""
+	### Deletes all the given paths (files or directories).
+
+	#### Params:
+	- path (list(str)): List of paths to delete.
+	"""
+	for path in paths:
+		if not os.path.exists(path):
+			continue
+		if os.path.isdir(path):
+			shutil.rmtree(path, ignore_errors=True)
+		else:
+			os.remove(path)

xmipp3_installer/shared/singleton.py

@@ -0,0 +1,25 @@
+"""### Contains a generic singleton class."""
+
+from typing_extensions import Self
+
+class Singleton:
+	"""
+	### Generic singleton class.
+	"""
+	__instance = None
+
+	def __new__(cls, *args, **kwrgs) -> Self:
+		"""
+		### Singleton instancer.
+
+		#### Params:
+		- cls (self): Current class.
+		- *args (any): Positional params.
+		- **kwargs (any): Argument params.
+
+		#### Returns:
+		- (self): Instance of current class.
+		"""
+		if not cls.__instance:
+			cls.__instance = super().__new__(cls)
+		return cls.__instance