| """General utilities.""" |
|
|
| import collections.abc |
| import contextlib |
| import os |
| import platform |
| import re |
| import shutil |
| import subprocess |
| import sys |
| from copy import deepcopy |
| from functools import partial |
| from importlib.resources import files |
| from pathlib import Path |
|
|
| import psutil |
|
|
| import haddock |
| from haddock import EmptyPath, log |
| from haddock.core.exceptions import SetupError |
| from haddock.core.typing import ( |
| PT, |
| Any, |
| AnyT, |
| Callable, |
| Container, |
| FilePath, |
| FilePathT, |
| Generator, |
| Iterable, |
| Optional, |
| ParamDict, |
| ParamMap, |
| ParamMapT, |
| Union, |
| ) |
| from haddock.gear.greetings import get_goodbye_help |
|
|
| check_subprocess = partial( |
| subprocess.run, |
| shell=True, |
| check=True, |
| stdout=subprocess.DEVNULL, |
| ) |
|
|
|
|
| def get_result_or_same_in_list( |
| function: Callable[[PT], AnyT], value: PT |
| ) -> Union[AnyT, list[PT]]: |
| """ |
| Return the result if True or the value within a list. |
| |
| Applies `function` to `value` and returns its result if it evaluates |
| to True. Otherwise, return the value within a list. |
| |
| `function` should receive a single argument, the `value`. |
| """ |
| result = function(value) |
| return result if result else [value] |
|
|
|
|
| def make_list_if_string(item: Union[str, list[str]]) -> list[str]: |
| """Put `item` into a list.""" |
| if isinstance(item, str): |
| return [item] |
| return item |
|
|
|
|
| def transform_to_list( |
| item: Union[Iterable[AnyT], AnyT], |
| ) -> Union[list[AnyT], tuple[AnyT, ...]]: |
| """ |
| Put `item` into a list if not a list already. |
| |
| If it is set, transforms the set into a list. |
| |
| If it is a dict, returns a list of the keys. |
| |
| If it is tuple, returns the tuple. |
| |
| If a list, returns the same. |
| |
| Everything else returns `item` inside a one element list. |
| """ |
| if isinstance(item, (set, dict)): |
| return list(item) |
|
|
| if isinstance(item, (list, tuple)): |
| return item |
|
|
| return [item] |
|
|
|
|
| def copy_files_to_dir(paths: Iterable[FilePath], directory: FilePath) -> None: |
| """ |
| Copy files to directory. |
| |
| Parameters |
| ---------- |
| paths : iterable of paths |
| Source files. |
| |
| directory : path |
| Where to copy files to. |
| """ |
| for path in paths: |
| shutil.copy(path, directory) |
|
|
|
|
| def remove_folder(folder: FilePath) -> None: |
| """ |
| Remove a folder if it exists. |
| |
| Parameters |
| ---------- |
| folder : str or Path |
| Path to folder to remove. |
| """ |
| if Path(folder).exists(): |
| log.warning(f"{folder} exists and it will be REMOVED!") |
| shutil.rmtree(folder) |
|
|
|
|
| def remove_dict_keys(d: ParamMap, keys: Container[str]) -> ParamDict: |
| """ |
| Remove `keys` from dictionary (`d`). |
| |
| Return |
| ------ |
| dict |
| A copy of `d` dictionary without the `keys`. |
| """ |
| return {k: deepcopy(v) for k, v in d.items() if k not in keys} |
|
|
|
|
| def cpu_count() -> int: |
| """Count number of available CPU for the process. |
| |
| User suggestion, by https://github.com/EricDeveaud |
| |
| Note: pid 0 == current process |
| |
| FIXME: from python3.13, better to use os.process_cpu_count() |
| |
| Returns |
| ------- |
| process_ncores : int |
| Number of cores allocated to the process pid. |
| """ |
|
|
| def _cpu_count() -> int: |
| """Detect number of cores available. |
| |
| Returns |
| ------- |
| ncores : int |
| Maximum number of cores that can be used. |
| """ |
| try: |
| |
| _process_ncores = os.sched_getaffinity(0) |
| if isinstance(_process_ncores, set): |
| ncores = len(_process_ncores) |
| else: |
| ncores = int(_process_ncores) |
| except AttributeError: |
| |
| |
| |
| ncores = int(os.cpu_count()) |
| return ncores |
|
|
| try: |
| process_ncores = int(os.process_cpu_count()) |
| except AttributeError: |
| process_ncores = _cpu_count() |
| return process_ncores |
|
|
|
|
| def parse_ncores( |
| n: Optional[Union[int, str]] = None, |
| njobs: Optional[int] = None, |
| max_cpus: Optional[bool] = None, |
| ) -> int: |
| """ |
| Check the number of cores according to HADDOCK3 architecture. |
| |
| Parameters |
| ---------- |
| n : int or str |
| The desired number of cores. If `None` is given, returns the |
| maximum number of cores allowed, see `max_cpus`. |
| |
| njobs : int |
| The number of jobs to execute. Optional. The number of cores |
| will be compared to `njobs`. |
| |
| max_cpus : int |
| The maximum number of CPUs allowed. If not specified, defaults |
| to the available CPUs minus one. |
| |
| Raises |
| ------ |
| SetupError |
| If `n` is not positive or not convertable to `int`. |
| |
| Returns |
| ------- |
| int |
| A correct number of cores according to specifications. |
| """ |
| if max_cpus is None or max_cpus is False: |
| max_cpus = max(cpu_count() - 1, 1) |
| if max_cpus is True: |
| max_cpus = cpu_count() |
| elif not isinstance(max_cpus, int): |
| raise TypeError(f"`max_cpus` not of valid type: {type(max_cpus)}") |
|
|
| if n is None: |
| return max_cpus |
|
|
| try: |
| n = int(n) |
| except (TypeError, ValueError) as err: |
| _msg = f"`n` must be `int` or `int`-convertable `str`: {n!r} given." |
| raise SetupError(_msg) from err |
|
|
| if n < 1: |
| _msg = f"`n` is not positive, this is not possible: {n!r}" |
| raise SetupError(_msg) |
|
|
| if njobs is not None: |
| ncores = min(n, njobs, max_cpus) |
| log.info( |
| f"Selected {ncores} cores to process {njobs} jobs, with {max_cpus} " |
| "maximum available cores." |
| ) |
| return ncores |
|
|
| log.debug(f"`njobs` not specified, evaluating initial value {n}...") |
| ncores = min(n, max_cpus) |
| log.debug(f"Selected {ncores} for a maximum of {max_cpus} CPUs") |
| return ncores |
|
|
|
|
| def non_negative_int( |
| n: Any, |
| exception: type[Exception] = ValueError, |
| emsg: str = "`n` do not satisfies", |
| ) -> int: |
| """ |
| Transform `n` in int and returns if `compare` evaluates to True. |
| |
| Parameters |
| ---------- |
| n : int-convertable |
| Something that can be converted to int. |
| |
| exception : Exception |
| The Exception to raise in case `n` is not a positive integer. |
| |
| emsg : str |
| The error message to give to `exception`. May accept formatting |
| to pass `n`. |
| |
| Raises |
| ------ |
| ValueError, TypeError |
| If `n` cannot be converted to `int` |
| """ |
| try: |
| n1 = int(n) |
| if n1 >= 0: |
| return n1 |
| except Exception as e: |
| raise e |
| else: |
| |
| raise exception(emsg.format(n)) |
|
|
|
|
| def recursive_dict_update(d: ParamMapT, u: ParamMap) -> ParamMapT: |
| """ |
| Update dictionary `d` according to `u` recursively. |
| |
| https://stackoverflow.com/questions/3232943 |
| |
| Returns |
| ------- |
| dict |
| A new dict object with updated key: values. The original dictionaries |
| are not modified. |
| """ |
|
|
| def _recurse(d_: ParamMapT, u_: ParamMap) -> ParamMapT: |
| for k, v in u_.items(): |
| if isinstance(v, collections.abc.Mapping): |
| d_[k] = _recurse(d_.get(k, {}), v) |
| else: |
| d_[k] = deepcopy(v) |
|
|
| return d_ |
|
|
| new = deepcopy(d) |
| _recurse(new, u) |
|
|
| return new |
|
|
|
|
| def get_number_from_path_stem(path: FilePath) -> int: |
| """ |
| Extract tail number from path. |
| |
| Examples |
| -------- |
| |
| >>> get_number_from_path_stem('src/file_1.pdb') |
| >>> 1 |
| |
| >>> get_number_from_path_stem('src/file_3.pdb') |
| >>> 3 |
| |
| >>> get_number_from_path_stem('file_1231.pdb') |
| >>> 1231 |
| |
| >>> get_number_from_path_stem('src/file11') |
| >>> 11 |
| |
| >>> get_number_from_path_stem('src/file_1234_1.pdb') |
| >>> 1 |
| |
| Parameters |
| ---------- |
| path : str or Path obj |
| The path to evaluate. |
| |
| Returns |
| ------- |
| int |
| The tail integer of the path. |
| """ |
| stem = Path(path).stem |
| number = re.findall(r"\d+", stem)[-1] |
| return int(number) |
|
|
|
|
| def sort_numbered_paths(*paths: FilePathT) -> list[FilePathT]: |
| """ |
| Sort input paths to tail number. |
| |
| If possible, sort criteria is provided by |
| :py:func:`get_number_from_path_stem`. |
| If paths do not have a numbered tag, sort paths alphabetically. |
| |
| Parameters |
| ---------- |
| *inputs : str or pathlib.Path |
| Paths to files. |
| |
| Returns |
| ------- |
| list |
| The sorted pathlist. The original types are not modified. If |
| strings are given, strings are returns, if Paths are given |
| paths are returned. |
| """ |
| try: |
| return sorted(paths, key=get_number_from_path_stem) |
| except TypeError as err: |
| log.exception(err) |
| emsg = ( |
| "Mind the packing *argument, input should be strings or Paths, not a list." |
| ) |
| raise TypeError(emsg) |
| except IndexError: |
| return sorted(paths, key=lambda x: Path(x).stem) |
|
|
|
|
| @contextlib.contextmanager |
| def log_error_and_exit() -> Generator[None, None, None]: |
| """Exit with exception.""" |
| try: |
| yield |
| except Exception as err: |
| log.exception(err) |
| log.error(err) |
| log.error( |
| "An error has occurred, see log file. And contact the developers if needed." |
| ) |
| log.info(get_goodbye_help()) |
| sys.exit(1) |
|
|
|
|
| def extract_keys_recursive(config: ParamMap) -> Generator[str, None, None]: |
| """Extract keys recursively for the needed modules.""" |
| for param_name, value in config.items(): |
| if isinstance(value, collections.abc.Mapping): |
| yield from extract_keys_recursive(value) |
| else: |
| yield param_name |
|
|
|
|
| def recursive_convert_paths_to_strings(params: ParamMapT) -> ParamMapT: |
| """ |
| Convert paths to strings recursively over a dictionary. |
| |
| Parameters |
| ---------- |
| params : dictionary |
| |
| Returns |
| ------- |
| dictionary |
| A copy of the original dictionary with paths converted to strings. |
| """ |
| params = deepcopy(params) |
| for param, value in params.items(): |
| if isinstance(value, (Path, EmptyPath)): |
| params[param] = str(value) |
| elif isinstance(value, collections.abc.Mapping): |
| params[param] = recursive_convert_paths_to_strings(value) |
| elif isinstance(value, (tuple, list)): |
| for i, v in enumerate(value): |
| if isinstance(v, (Path, EmptyPath)): |
| value[i] = str(v) |
| params[param] = value |
|
|
| return params |
|
|
|
|
| def get_arch(): |
| """Helper function to figure out the architetchure""" |
| system = platform.system().lower() |
| machine = platform.machine().lower() |
|
|
| return f"{machine}-{system}" |
|
|
|
|
| def get_cns_executable() -> tuple[Path, Path]: |
| """ |
| Locate CNS executable and its Linux variant for grid execution. |
| |
| Returns: |
| Tuple of (cns_exec, cns_exec_linux) paths |
| |
| Raises: |
| SystemExit: If CNS executable cannot be found |
| """ |
| cns_exec_dir = Path(files(haddock).joinpath("cns/bin")) |
| arch = get_arch() |
| cns_exec = Path(cns_exec_dir, f"{arch}.bin") |
| if not cns_exec.exists(): |
| log.error("CNS executable not found at %s", cns_exec) |
|
|
| |
| cns_exec_env = os.environ.get("CNS_EXEC") |
| if cns_exec_env is None: |
| log.error( |
| "Please define the CNS binary location by setting the CNS_EXEC " |
| "environment variable" |
| ) |
| sys.exit(1) |
|
|
| cns_exec = Path(cns_exec_env) |
| if not cns_exec.exists(): |
| log.error("CNS executable not found at %s", cns_exec) |
| sys.exit(1) |
|
|
| |
| cns_exec_linux = Path(cns_exec_dir, "x86_64-linux.bin") |
|
|
| if not cns_exec_linux.exists(): |
| log.warning( |
| "Current architecture is %s, but grid execution requires " |
| "an x86_64-linux binary", |
| arch, |
| ) |
| log.warning("Linux CNS binary not found at %s", cns_exec_linux) |
| log.warning("GRID mode will not be available") |
|
|
| return cns_exec, cns_exec_linux |
|
|
|
|
| def get_prodrg_exec() -> tuple[Optional[Path], Optional[Path]]: |
| """ |
| Locate the prodrg binary and its parameter file. |
| |
| Returns ``(None, None)`` with a warning if the binary cannot be found, |
| allowing the application to start normally. The error will surface later |
| if ``run_prodrg`` is actually called. |
| |
| Returns: |
| Tuple of (prodrg_exec, prodrg_param) paths, or (None, None) if not found |
| """ |
| prodrg_dir = Path(files(haddock).joinpath("prodrg")) |
| arch = get_arch() |
| prodrg_exec = prodrg_dir / f"prodrg_{arch}" |
|
|
| if not prodrg_exec.exists(): |
| prodrg_exec_env = os.environ.get("PRODRG_EXEC") |
| if prodrg_exec_env is not None: |
| prodrg_exec = Path(prodrg_exec_env) |
| else: |
| log.warning( |
| "prodrg binary not found for arch %s and PRODRG_EXEC is not set. " |
| "Automated ligand topology generation will not be available.", |
| arch, |
| ) |
| return None, None |
|
|
| if not prodrg_exec.exists(): |
| log.warning( |
| "prodrg executable not found at %s. " |
| "Automated ligand topology generation will not be available.", |
| prodrg_exec, |
| ) |
| return None, None |
|
|
| prodrg_param = prodrg_dir / "prodrg.param" |
| if not prodrg_param.exists(): |
| log.warning( |
| "prodrg.param not found at %s. " |
| "Automated ligand topology generation will not be available.", |
| prodrg_param, |
| ) |
| return None, None |
|
|
| return prodrg_exec, prodrg_param |
|
|
|
|
| def get_available_memory() -> float: |
| """ |
| Get the available system memory in GB. |
| |
| Get the available virtual memory in Bytes |
| then divide it by (1024 ^ 3) to get this value in GigaBytes |
| |
| Returns |
| ------- |
| float |
| Available memory in gigabytes (GB). |
| """ |
| return psutil.virtual_memory().available / (1024**3) |
|
|
|
|
| def get_necessary_memory(models: list) -> float: |
| """ |
| Estimate the memory required to compute contact maps. |
| |
| Calculates memory based on the largest model's estimated atom count. |
| The memory estimate assumes a distance matrix of size (atoms x atoms) * 8 bytes. |
| |
| Parameters |
| ---------- |
| models : list |
| List of model objects with file_name attribute. |
| |
| Returns |
| ------- |
| float |
| Estimated memory requirement in gigabytes (GB). |
| """ |
| |
| |
| try: |
| file_size = os.path.getsize(models[0].file_name) |
| estimated_atoms = file_size // 10 |
| except Exception: |
| estimated_atoms = 10000 |
|
|
| if estimated_atoms == 0: |
| estimated_atoms = 10000 |
|
|
| matrix_size_bytes = (estimated_atoms * estimated_atoms) * 8 |
| |
| matrix_size_gb = matrix_size_bytes / (1024**3) |
|
|
| return matrix_size_gb |
|
|
