xmipp3-installer 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

xmipp3_installer/installer/handlers/shell_handler.py

@@ -10,105 +10,104 @@ 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
+  cmd: str,
+  *,
+  cwd: str='./',
+  show_command: bool=False,
+  show_output: bool=False,
+  show_error: bool=False
 ) -> Tuple[int, str]:
-	"""
-	### This function runs the given command.
+  """
+  ### 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.
+  #### 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.
 
-	#### 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)
+  #### 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))
+  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
+  if not ret_code and show_output:
+    logger(output_str)
+  
+  if ret_code and show_error:
+    logger(logger.red(output_str))
+  
+  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
+  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.
+  """
+  ### 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.
+  #### 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()
+  #### Returns:
+  - (int): Return code.
+  """
+  logger(cmd, substitute=substitute)
+  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
+  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.
+  """
+  ### Runs the given shell command.
 
-	#### Params:
-	- cmd (str): Command to run.
-	- cwd (str): Optional. Path to run the command from.
+  #### 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
+  #### 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

@@ -1,3 +1,9 @@
+"""
+### Versions Manager Module.
+
+This module contains the class to manage version information.
+"""
+
 import json
 from datetime import datetime
 from typing import Dict, List
@@ -6,6 +12,12 @@ from xmipp3_installer.installer import constants
 from xmipp3_installer.shared import singleton
 
 class VersionsManager(singleton.Singleton):
+  """
+  ### Versions Manager.
+
+  Manages version information by reading and validating version data from a JSON file.
+  """
+
   def __init__(self, version_file_path: str):
     """
     ### Constructor.
@@ -27,14 +39,14 @@ class VersionsManager(singleton.Singleton):
     self.sources_versions = version_info["sources_target_tag"]
     self.__validate_fields()
 
-  def __get_version_info(self) -> Dict[str, str]:
+  def __get_version_info(self) -> Dict[str, Dict[str, str]]:
     """
     ### Retrieves the version info from the version information JSON file.
 
     #### Returns:
-    - (dict(str, str)): Dictionary containing the parsed values.
+    - (dict(str, dict(str, str))): Dictionary containing the parsed values.
     """
-    with open(self.version_file_path) as json_data:
+    with open(self.version_file_path, encoding="utf-8") as json_data:
       version_info = json.load(json_data)
     return version_info
   
@@ -62,12 +74,13 @@ class VersionsManager(singleton.Singleton):
     - ValueError: If any version number doesn't follow the required format.
     """
     parts = self.xmipp_version_number.split('.')
-    if not self.__is_valid_semver(parts):
+    if not VersionsManager.__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:
+  @staticmethod
+  def __is_valid_semver(version_parts: List[str]) -> bool:
     """
     ### Checks if version parts constitute a valid semantic version.
     
@@ -77,7 +90,8 @@ class VersionsManager(singleton.Singleton):
     #### Returns:
     - (bool): True if version follows semver format, False otherwise.
     """
-    return len(version_parts) == 3 and all(part.isdigit() for part in version_parts)
+    SEMVER_N_NUMBERS = 3 # 3 numbers separated by dots: X.Y.Z
+    return len(version_parts) == SEMVER_N_NUMBERS and all(part.isdigit() for part in version_parts)
 
   def __validate_release_date(self):
     """

xmipp3_installer/installer/installer_service.py

@@ -1,4 +1,10 @@
-from typing import Dict
+"""
+### Installer Service Module.
+
+This module contains the class to manage the installation process.
+"""
+
+from typing import Dict, cast
 
 from xmipp3_installer.api_client import api_client
 from xmipp3_installer.api_client.assembler import installation_info_assembler
@@ -15,13 +21,19 @@ from xmipp3_installer.repository import config
 from xmipp3_installer.repository.config_vars import variables
 
 class InstallationManager:
+  """
+  ### Installation Manager.
+
+  Manages the installation process by executing the appropriate mode based on the given arguments.
+  """
+  
   def __init__(self, args: Dict):
     """
-		### Constructor.
+    ### Constructor.
 		
-		#### Params:
-		- args (dict): Dictionary containing all parsed command-line arguments.
-		"""
+    #### 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 = {
@@ -50,7 +62,7 @@ class InstallationManager:
       self.mode_executor.sends_installation_info and 
       self.context[variables.SEND_INSTALLATION_STATISTICS]
     ):
-      logger("Sending anonymous installation info...")
+      logger("Sending anonymous installation info...", show_in_terminal=False)
       api_client.send_installation_attempt(
         installation_info_assembler.get_installation_info(
           self.context[constants.VERSIONS_CONTEXT_KEY],
@@ -59,8 +71,10 @@ class InstallationManager:
       )
     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
+        cast(
+          versions_manager.VersionsManager,
+          self.context[constants.VERSIONS_CONTEXT_KEY]
+        ).xmipp_version_number
       ))
     logger.close()
     return ret_code
-  

xmipp3_installer/installer/modes/mode_all_executor.py

@@ -1,63 +1,73 @@
+"""
+### Mode All Executor Module.
+
+This module contains the class to run the whole installation process.
+"""
+
 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
+  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
+  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
+  """
+  ### Mode All Executor.
+
+  Runs the whole installation process with the appropriate parameters.
+  """
+  
+  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
     )
-		compile_and_install_executor = mode_compile_and_install_executor.ModeCompileAndInstallExecutor(
-			{**context, params.PARAM_BRANCH: None}
+    config_build_executor = mode_config_build_executor.ModeConfigBuildExecutor(
+      context
     )
-		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, ""
+    compile_and_install_executor = mode_compile_and_install_executor.ModeCompileAndInstallExecutor(
+      context
+    )
+    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/mode_clean_all_executor.py

@@ -1,3 +1,9 @@
+"""
+### Mode Clean All Executor Module.
+
+This module contains the class to clean all content from source and build directories.
+"""
+
 from typing import List
 
 from xmipp3_installer.application.logger.logger import logger
@@ -6,39 +12,41 @@ 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):")
-		])
-	
+  """
+  ### Mode Clean All Executor.
+
+  Cleans all content from source and build directories.
+  """
+
+  @property
+  def confirmation_keyword(self) -> str:
+    """### Property containineg the keyword to confirm the cleaning operation."""
+    return "YeS"
+
+  @staticmethod
+  def _get_paths_to_delete() -> 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_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.confirmation_keyword}' (case sensitive):")
+    ])