Add files using upload-large-folder tool

.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Simon Mitternacht
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

.venv_haddock/lib/python3.12/site-packages/haddock/clis/__init__.py

@@ -0,0 +1,8 @@
+"""
+Command-line interfaces.
+
+HADDOCK3 has a series of command-line interfaces (CLIs), from which the most important
+one is ``haddock3``. You can ask help to the CLIs with the ``-h`` flag::
+
+    haddock3 -h
+"""

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+Run HADDOCK3 docking simulation.
+
+This is the main command-line client to run HADDOCK3 docking
+simulations. To prepare a simulation, setup configuration file defining
+a HADDOCK3 workflow and use this command-line client to execute that
+workflow.
+
+Usage::
+
+    haddock3 -h
+    haddock3 <CONFIG FILE>
+"""
+import argparse
+import sys
+from pathlib import Path
+
+from haddock import log
+from haddock.core.defaults import RUNDIR
+from haddock.core.typing import (
+    ArgumentParser,
+    Callable,
+    FilePath,
+    LogLevel,
+    Namespace,
+    Optional,
+)
+from haddock.gear.extend_run import EXTEND_RUN_DEFAULT, add_extend_run
+from haddock.gear.restart_run import add_restart_arg
+from haddock.libs.libcli import add_version_arg, arg_file_exist
+from haddock.libs.liblog import add_loglevel_arg
+
+
+# Command line interface parser
+ap = argparse.ArgumentParser()
+
+ap.add_argument(
+    "workflow",
+    type=arg_file_exist,
+    help=(
+        "The input configuration file path describing "
+        "the workflow to be performed"
+        ),
+    )
+
+add_restart_arg(ap)
+add_extend_run(ap)
+
+ap.add_argument(
+    "--setup",
+    help="Only setup the run, do not execute",
+    action="store_true",
+    dest="setup_only",
+)
+
+add_loglevel_arg(ap)
+add_version_arg(ap)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = load_args(ap)
+    main(**vars(cmd))
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(_ap(), main)
+
+
+def main(
+    workflow: FilePath,
+    restart: Optional[int] = None,
+    extend_run: Optional[FilePath] = EXTEND_RUN_DEFAULT,
+    setup_only: bool = False,
+    log_level: LogLevel = "INFO",
+) -> None:
+    """
+    Run an HADDOCK3 workflow.
+
+    Parameters
+    ----------
+    workflow : str or pathlib.Path
+        The path to the workflow (config file).
+
+    restart : int
+        The step to restart the run from (inclusive).
+        Defaults to None, which ignores this option.
+
+    extend_run : str or Path
+        The path created with `haddock3-copy` to start the run from.
+        Defaults to None, which ignores this option.
+
+    setup_only : bool, optional
+        Whether to setup the run without running it.
+        Defaults to False.
+
+    log_level : str, optional
+        The logging level: INFO, DEBUG, ERROR, WARNING, CRITICAL.
+    """
+    # anti-pattern to speed up CLI initiation
+    from time import time
+
+    from haddock.gear.extend_run import WorkflowManagerExtend
+    from haddock.gear.greetings import (
+        get_adieu,
+        get_initial_greeting,
+        gen_feedback_messages,
+        )
+    from haddock.gear.postprocessing import archive_run
+    from haddock.gear.prepare_run import setup_run
+    from haddock.libs.libio import working_directory
+    from haddock.libs.liblog import (
+        add_log_for_CLI,
+        add_stringio_handler,
+        log_file_name,
+        log_formatters,
+    )
+    from haddock.libs.libtimer import convert_seconds_to_min_sec
+    from haddock.libs.libutil import log_error_and_exit
+    from haddock.libs.libworkflow import WorkflowManager
+    from haddock.modules import get_module_steps_folders
+
+    start = time()
+    # the io.StringIO handler is a trick to save the log while run_dir
+    # is not read from the configuration file and the log can be saved
+    # in the final file.
+    #
+    # Nonetheless, the log is saved in stdout and stderr in case it
+    # breaks before the actual logfile is defined.
+    # See lines further down on how we resolve this trick
+    add_stringio_handler(
+        log,
+        log_level=log_level,
+        formatter=log_formatters[log_level],
+    )
+
+    log.info(get_initial_greeting())
+
+    with log_error_and_exit():
+        params, other_params = setup_run(
+            workflow,
+            restart_from=restart,
+            extend_run=extend_run,
+        )
+
+    # here we the io.StringIO handler log information, and reset the log
+    # handlers to fit the CLI and HADDOCK3 specifications.
+    log_temporary = log.handlers[-1].stream.getvalue()  # type: ignore
+    _run_dir: str = other_params[RUNDIR]
+    log_file = Path(_run_dir, log_file_name)
+    add_log_for_CLI(log, log_level, log_file)
+
+    # here we append the log information in the previous io.StringIO()
+    # handler in the log file already in the run_dir
+    with open(log_file, "a") as fout:
+        fout.write(log_temporary)
+
+    if setup_only:
+        log.info("We have setup the run, only.")
+        gen_feedback_messages(log.info)
+        log.info(get_adieu())
+        return
+
+    if extend_run:
+        steps_folders = get_module_steps_folders(extend_run)
+        restart_step = max([int(fold.split('_')[0]) for fold in steps_folders])
+        restart_step += 1
+        WorkflowManager_ = WorkflowManagerExtend
+
+    else:
+        restart_step = restart
+        WorkflowManager_ = WorkflowManager
+
+    with (working_directory(_run_dir), log_error_and_exit()):
+        workflow = WorkflowManager_(
+            workflow_params=params,
+            start=restart_step,
+            **other_params,
+        )
+
+        # Main loop of execution
+        workflow.run()
+
+        # Run post-processing steps
+        if other_params["postprocess"]:
+            workflow.postprocess(self_contained=other_params["gen_archive"])
+        # Clean outputs
+        workflow.clean()
+
+    # Generate archive of the run
+    if other_params["gen_archive"]:
+        _run_archive, _analysis_archive = archive_run(_run_dir)
+        log.info(f"Run archive created: {_run_archive}!")
+        if _analysis_archive:
+            log.info(f"Run analysis archive created: {_analysis_archive}")
+
+    # Finish
+    end = time()
+    elapsed = convert_seconds_to_min_sec(end - start)
+    log.info(f"This HADDOCK3 run took: {elapsed}")
+    gen_feedback_messages(log.info)
+    log.info(get_adieu())
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_analyse.py

@@ -0,0 +1,864 @@
+"""
+Analyse a set of steps of a run.
+
+Considering the example run::
+
+    run1/
+        0_topoaa/
+        1_rigidbody/
+        2_seletop/
+        3_flexref/
+        (etc...)
+
+
+USAGE::
+
+    haddock3-analyse -r <run_dir> -m <num_modules>
+    haddock3-analyse -r run1 -m 1 3
+
+
+Where, ``-m 1 3`` means that the analysis will be performed on ``1_rigidbody``
+ and ``3_flexref``.
+"""
+
+import argparse
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from haddock import log
+from haddock.clis.cli_unpack import main as haddock3_unpack
+from haddock.clis.cli_clean import main as haddock3_clean
+from haddock.core.defaults import INTERACTIVE_RE_SUFFIX
+from haddock.core.typing import (
+    Any,
+    ArgumentParser,
+    Callable,
+    FilePath,
+    ImgFormat,
+    Namespace,
+    Optional,
+    ParamDict,
+    ParamMap,
+    )
+from haddock.gear.yaml2cfg import read_from_yaml_config
+from haddock.gear.clean_steps import _unpack_gz
+from haddock.libs.libcli import _ParamsToDict
+from haddock.libs.libio import archive_files_ext
+from haddock.libs.libontology import ModuleIO
+from haddock.libs.libplots import (
+    ClRank,
+    box_plot_handler,
+    clt_table_handler,
+    read_capri_table,
+    report_generator,
+    scatter_plot_handler,
+    SUPPORTED_OUTPUT_FORMATS,
+    )
+from haddock.modules import get_module_steps_folders
+from haddock.modules.analysis.caprieval import (
+    DEFAULT_CONFIG as caprieval_params,
+    )
+from haddock.modules.analysis.caprieval import HaddockModule
+
+
+ANA_FOLDER = "analysis"  # name of the analysis folder
+INTER_STR = INTERACTIVE_RE_SUFFIX  # suffix of interactive analysis folders
+
+
+# Command line interface parser
+ap = argparse.ArgumentParser(
+    prog="haddock3-analyse",
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+ap.add_argument(
+    "-r",
+    "--run-dir",
+    help="The input run directory.",
+    required=True,
+)
+
+ap.add_argument(
+    "-m",
+    "--modules",
+    nargs="+",
+    help="The number of the steps to copy.",
+    required=True,
+    type=int,
+)
+
+ap.add_argument(
+    "-t",
+    "--top_clusters",
+    help="The number of clusters to show.",
+    required=False,
+    type=int,
+    default=10,
+)
+
+ap.add_argument(
+    "--format",
+    help="produce images in the desired format",
+    required=False,
+    type=str,
+    default=None,
+    choices=list(SUPPORTED_OUTPUT_FORMATS),
+)
+
+ap.add_argument(
+    "--scale", help="scale for images", required=False, type=float, default=1.0
+)
+
+ap.add_argument(
+    "--inter",
+    help="interactive analysis",
+    required=False,
+    type=bool,
+    default=False,
+    )
+
+ap.add_argument(
+    "--is_cleaned",
+    help="is the directory going to be cleaned?",
+    required=False,
+    type=bool,
+    default=False,
+)
+
+ap.add_argument(
+    "--offline",
+    help="Should plots js functions be self-contained?",
+    required=False,
+    type=bool,
+    default=False,
+)
+
+ap.add_argument(
+    "--mode",
+    help="mode of execution",
+    required=False,
+    type=str,
+    default="local",
+    choices=["local", "batch", "mpi"],
+)
+
+ap.add_argument(
+    "--ncores",
+    help="number of cores to use",
+    required=False,
+    type=int,
+    default=1,
+)
+
+ap.add_argument(
+    "--self-contained",
+    help="If self-contained is set, models will be copied locally in the analysis directory, allowing to visualize structures outside of the haddock3 run.",
+    required=False,
+    default=False,
+    type=bool,
+)
+
+
+ap.add_argument(
+    "-p",
+    "--other-params",
+    dest="other_params",
+    help=(
+        "Any other parameter of the `caprieval` module."
+        "For example: -p reference_fname target.pdb."
+        "You can give any number of parameters."
+    ),
+    action=_ParamsToDict,
+    default={},
+    nargs="*",
+)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = vars(load_args(ap))
+    kwargs = cmd.pop("other_params")
+    main(**cmd, **kwargs)
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(_ap(), main)
+
+
+def get_cluster_ranking(
+        capri_clt_filename: FilePath,
+        top_clusters: int,
+        ) -> ClRank:
+    """
+    Get capri cluster ranking.
+
+    Parameters
+    ----------
+    capri_clt_filename : str or Path
+        capri cluster filename
+    top_clusters : int
+        Number of clusters to be considered
+
+    Returns
+    -------
+    cl_ranking : dict
+        {cluster_id : cluster_rank} dictionary
+    """
+    cl_ranking: ClRank = {}
+    dfcl = read_capri_table(capri_clt_filename)
+    for n in range(min(top_clusters, dfcl.shape[0])):
+        cl_ranking[dfcl["cluster_id"].iloc[n]] = dfcl["caprieval_rank"].iloc[n]
+    return cl_ranking
+
+
+def update_paths(
+    capri_ss_filename: FilePath, toch: str = "../", toadd: str = "../../"
+) -> None:
+    """
+    Update paths in capri_ss_filename.
+
+    Parameters
+    ----------
+    capri_ss_filename : str or Path
+        capri ss filename
+    toch : str
+        string to be replaced
+    toadd : str
+        string to be added
+    """
+    new_lines: list[str] = []
+    with open(capri_ss_filename, "r") as rfile:
+        for ln in rfile:
+            new_ln = ln.replace(toch, toadd)
+            new_lines.append(new_ln)
+
+    with open(capri_ss_filename, "w") as wfile:
+        for ln in new_lines:
+            wfile.write(ln)
+    return
+
+
+def run_capri_analysis(
+        step: str,
+        run_dir: FilePath,
+        capri_dict: ParamMap,
+        is_cleaned: bool,
+        mode: str,
+        ncores: int,
+        ) -> None:
+    """
+    Run the caprieval analysis.
+
+    Parameters
+    ----------
+    step : str
+        step name
+    run_dir : str or Path
+        path to run directory
+    capri_dict : dict
+        capri dictionary of parameters
+    """
+    # retrieve json file with all information
+    io = ModuleIO()
+    filename = Path("..", f"{step}/io.json")
+    io.load(filename)
+    # unpack the files if they are compressed
+    if is_cleaned:
+        path_to_unpack = io.output[0].rel_path.parent
+        haddock3_unpack(path_to_unpack, ncores=ncores)
+    # define step_order. We add one to it, as the caprieval module will
+    # interpret itself as being after the selected step
+    step_order = int(step.split("_")[0]) + 1
+    # create capri
+    caprieval_module = HaddockModule(
+        order=step_order,
+        path=Path(run_dir),
+        init_params=caprieval_params,
+    )
+    caprieval_module.update_params(**capri_dict)
+    # updating mode and ncores
+    caprieval_module.params["mode"] = mode
+    caprieval_module.params["ncores"] = ncores
+    # update model info
+    caprieval_module.previous_io = io
+    # run capri module
+    caprieval_module._run()
+    # compress files if they should be compressed
+    if is_cleaned:
+        haddock3_clean(path_to_unpack, ncores=ncores)
+
+
+def update_capri_dict(default_capri: ParamDict, kwargs: ParamMap) -> ParamDict:
+    """
+    Update capri dictionary.
+
+    Parameters
+    ----------
+    default_capri : dict
+        default capri dictionary of parameters
+    kwargs : dict
+        dictionary of input elements
+
+    Returns
+    -------
+    capri_dict : dict
+        updated capri dictionary of parameters
+    """
+    capri_dict = default_capri.copy()
+    for param in kwargs:
+        if param not in default_capri:
+            sys.exit(
+                f"* ERROR * Parameter {param!r} is not "
+                "a valid `caprieval` parameter"
+                )
+        else:
+            if param.endswith("fname"):  # using full path for files
+                rel_path = Path(kwargs[param])
+                _param = rel_path.resolve()
+                kwargs[param] = _param
+            capri_dict[param] = kwargs[param]
+            log.info(f"setting {param} to {kwargs[param]}")
+
+    return capri_dict
+
+
+def update_paths_in_capri_dict(
+    capri_dict: ParamDict, target_path: FilePath
+) -> ParamDict:
+    """
+    Make capri_dict specific to target_path.
+
+    Parameters
+    ----------
+    capri_dict : dict
+        capri dictionary of parameters
+    target_path : Path
+        path to the output folder
+
+    Returns
+    -------
+    new_capri_dict : dict
+        target_path-specific capri dictionary of parameters
+    """
+    new_capri_dict = capri_dict.copy()
+    for key in new_capri_dict:
+        if key.endswith("fname") and new_capri_dict[key] not in ["", None]:
+            try:
+                ref_path = Path(target_path, "reference.pdb")
+                shutil.copy(new_capri_dict[key], ref_path)
+                new_capri_dict[key] = Path("reference.pdb")
+            except FileNotFoundError:
+                sys.exit(f"file not found {new_capri_dict[key]}")
+    return new_capri_dict
+
+
+def get_top_ranked_mapping(
+        capri_filename: FilePath,
+        cluster_ranking: ClRank,
+        clustered_topX: int = 4,
+        unclustered_topX: int = 10,
+        ) -> dict[Path, Path]:
+    """Obtain mapping of top ranked files to their future paths.
+
+    Parameters
+    ----------
+    capri_filename : FilePath
+        capri_ss.tsv filepath
+    cluster_ranking : ClRank
+        Cluster ranking, if the form of {cluster_id: cluster_rank} dictionary
+    clustered_topX : int, optional
+        Number of models to access per cluster. Default is 4.
+    unclustered_topX : int, optional
+        Number of unclustered models to access. Default is 10.
+
+    Returns
+    -------
+    top_ranked_mapping : dict[Path, Path]
+        Mapping between original filepath and new (future) one
+    """
+    # Set mapping of generated files
+    top_ranked_mapping: dict[Path, Path] = {}
+
+    # Read table
+    capri_df = read_capri_table(capri_filename, comment="#")
+    # Group by clusters
+    gb_cluster = capri_df.groupby("cluster_id")
+
+    # Loop over clusters
+    for cl_id, cl_df in gb_cluster:
+        # Filter only top clusters
+        if cl_id in cluster_ranking.keys():
+            # If clustered structure
+            if cl_id != "-":
+                # Retrieve only top 4 models per cluster
+                structs = cl_df.loc[cl_df["model-cluster_ranking"] <= clustered_topX][["model", "model-cluster_ranking"]]  # noqa : E501
+            # If un-clustered structures
+            else:
+                # Retrieve top 10
+                structs = cl_df.loc[cl_df["caprieval_rank"] <= unclustered_topX][["model", "caprieval_rank"]]  # noqa : E501
+            # Rename columns to access them using same keywords
+            structs.columns = ["model", "rank"]
+            # iterate over the structures
+            for _, row in structs.iterrows():
+                # Point rank
+                rank = row["rank"]
+                # set target name
+                if cl_id != "-":
+                    # Give it its cluster name
+                    target_name = (
+                        f"cluster_{cluster_ranking[cl_id]}"
+                        f"_model_{rank}.pdb"
+                        )
+                else:
+                    # Give it its rank name
+                    target_name = f"model_{rank}.pdb"
+
+                # Generate structure path
+                struct = Path(row["model"])
+                struct_gz = Path(f"{struct}.gz")
+                # copy the structure
+                if Path(struct).exists():
+                    top_ranked_mapping[struct] = Path(target_name)
+                elif struct_gz.exists():
+                    top_ranked_mapping[struct_gz] = Path(target_name)
+                else:
+                    log.warning(f"structure {struct} not found")
+    return top_ranked_mapping
+
+def zip_top_ranked(
+        top_ranked_mapping: dict[Path, Path],
+        summary_name: str,
+        gen_archive: bool,
+        ) -> Optional[Path]:
+    """
+    Zip the top ranked structures.
+
+    Parameters
+    ----------
+    capri_filename : str or Path
+        capri ss filename
+    cluster_ranking : dict
+        {cluster_id : cluster_rank} dictionary
+    summary_name: str
+        Base name of the archive to be generated
+    gen_archive: bool
+        Should the archive be generated?
+    clustered_topX: int
+        Number of models to access per cluster. Default is 4.
+    unclustered_topX: int
+        Number of models to access when no clusters. Default is 10.
+
+    Return
+    ------
+    output_fname : Optional[Path]
+        Path to the generated output. Can be a .tgz archive or a directory.
+    """
+    for ori_fpath, new_name in top_ranked_mapping.items():
+        # If already compressed
+        if ori_fpath.suffix == ".gz":
+            copied_fpath = Path(shutil.copy(ori_fpath, "."))
+            # unpack the file
+            _unpack_gz(copied_fpath)
+            # Rename it
+            shutil.move(copied_fpath.name.replace(".gz", ""), new_name)
+        else:
+            shutil.copy(ori_fpath, new_name)
+
+    # Compress pdb files
+    if gen_archive:
+        archive_was_created = archive_files_ext(".", "pdb")
+        # Delete the pdb files
+        for file_ in top_ranked_mapping.values():
+            Path(file_).unlink()
+        output_fname = Path(f"{summary_name}.tgz")
+        if archive_was_created:
+            # move archive to summary
+            shutil.move("pdb.tgz", output_fname)
+            log.info(f"Top structures summary archive {output_fname} created!")
+            return 
+        else:
+            log.warning(f"Summary archive {output_fname} not created!")
+            return None
+    # Generate a directory holding all the structures
+    else:
+        output_fname = Path(summary_name)
+        output_fname.mkdir(parents=True, exist_ok=True)
+        for ori_fpath, new_name in top_ranked_mapping.items():
+            # Create new path
+            next_filepath = Path(output_fname, str(new_name))
+            # Hold it in mapping dict
+            top_ranked_mapping[ori_fpath] = Path(next_filepath)
+            # Displace file
+            shutil.move(new_name, top_ranked_mapping[ori_fpath])
+        log.info(f"Top structures copied into {output_fname}!")
+        return output_fname
+
+
+def analyse_step(
+    step: str,
+    run_dir: FilePath,
+    capri_dict: ParamDict,
+    target_path: Path,
+    top_clusters: int,
+    format: Optional[ImgFormat],
+    scale: Optional[float],
+    is_cleaned: Optional[bool],
+    offline: bool = False,
+    mode: str = "local",
+    ncores: int = 4,
+    self_contained: bool = False,
+    clustered_topX: int = 4,
+    unclustered_topX: int = 10,
+) -> None:
+    """
+    Analyse a step.
+
+    If the step is a caprieval step, use the available capri files.
+    Otherwise, launch a capri analysis.
+
+    Parameters
+    ----------
+    step : str
+        step name
+    run_dir : str or Path
+        path to run directory
+    capri_dict : dict
+        capri dictionary of parameters
+    target_path : Path
+        path to the output folder
+    top_clusters : int
+        Number of clusters to be considered
+    format : str
+        Produce images in the selected format.
+    scale : int
+        scale for images.
+    is_cleaned: bool
+        is the directory going to be cleaned?
+    offline: bool
+        Should plots js functions be self-contained?
+    mode: str
+        mode of execution
+    ncores: int
+        number of cores to use
+    self_contained : bool
+        Should the analysis directory contain the models?
+    clustered_topX: int
+        Number of models to access per cluster. Default is 4.
+    unclustered_topX: int
+        Number of models to access when no clusters. Default is 10.
+    """
+    log.info(f"Analysing step {step}")
+    # Create directory
+    target_path.mkdir(parents=True, exist_ok=False)
+    # Build caprieval output file names/paths
+    ss_filename = Path("capri_ss.tsv")
+    clt_filename = Path("capri_clt.tsv")
+    step_name = step.split("_")[1]
+    ss_fname = Path(run_dir, f"{step}/{ss_filename}")
+    clt_fname = Path(run_dir, f"{step}/{clt_filename}")
+    # Search for caprieval output files
+    if step_name != "caprieval":
+        if ss_fname.exists() and clt_fname.exists():
+            log.info(f"step {step} has caprieval data, files are available")
+            run_capri = False
+        else:
+            capri_dict = update_paths_in_capri_dict(capri_dict, target_path)
+            run_capri = True
+    else:
+        log.info(f"step {step} is caprieval, files should be already available")
+        run_capri = False
+
+    # If caprieval data available, just copy them
+    if not run_capri:
+        shutil.copy(ss_fname, target_path)
+        shutil.copy(clt_fname, target_path)
+
+    # Go to directory where to write all the analysis figures / report
+    os.chdir(target_path)
+    # if the step is not caprieval, caprieval must be run
+    if run_capri:
+        run_capri_analysis(step, run_dir, capri_dict, is_cleaned, mode, ncores)
+
+    log.info("CAPRI files identified")
+    # plotting
+
+    if clt_filename.exists():
+        cluster_ranking = get_cluster_ranking(clt_filename, top_clusters)
+    else:
+        raise Exception(f"clustering file {clt_filename} does not exist")
+    if ss_filename.exists():
+        # Generate file mapping for top ranked structures
+        top_ranked_mapping = get_top_ranked_mapping(
+            ss_filename,
+            cluster_ranking,
+            clustered_topX=clustered_topX,
+            unclustered_topX=unclustered_topX,
+            )
+        # provide a zipped archive of the top ranked structures
+        zip_top_ranked(
+            top_ranked_mapping,
+            "summary",
+            not self_contained,
+            )
+        log.info("Plotting results..")
+        scatters = scatter_plot_handler(
+            ss_filename,
+            cluster_ranking,
+            format,
+            scale,
+            offline=offline,
+            )
+        boxes = box_plot_handler(
+            ss_filename,
+            cluster_ranking,
+            format,
+            scale,
+            offline=offline,
+            )
+        tables = clt_table_handler(
+            clt_filename,
+            ss_filename,
+            is_cleaned,
+            topX_clusters=top_clusters,
+            clustered_topX=clustered_topX,
+            unclustered_topX=unclustered_topX,
+            top_ranked_mapping=top_ranked_mapping if self_contained else None,
+            )
+        report_generator(boxes, scatters, tables, step, ".", offline)
+
+
+def validate_format(_format: Optional[ImgFormat]) -> Optional[ImgFormat]:
+    """Validate the optional argument `format`.
+
+    Parameters
+    ----------
+    _format : Optional[ImgFormat]
+        A optential output format set by the user.
+
+    Returns
+    -------
+    Optional[ImgFormat]
+        A valid output format for the figures to be generated.
+
+    Raises
+    ------
+    ImportError
+        When the kaleido package is not installed.
+    ValueError
+        When the export format is not supported by plotly / kaleido.
+    """
+    # Optional, so if not defined, return _format (None)
+    if not _format:
+        return _format
+    # Make sure it is lower case
+    format = _format.lower()
+    # Check if part of supported output formats
+    if format in SUPPORTED_OUTPUT_FORMATS:
+        # Make sure the `kaleido` package is installed
+        try:
+            import kaleido  # noqa : F401
+        except ImportError:
+            raise ImportError(
+                f"Exporting with format {format} requires the use of `kaleido`"
+                f" package, that seems not to be installed. {os.linesep}"
+                "Please install it with: `pip install kaleido==0.2.*`"
+                )
+        # At this stage, everything should go smooth with the export format
+        else:
+            # Return supported format
+            return format
+    # Raise error if unsupported format
+    raise ValueError(
+        f"Format `{format}` is not supported.{os.linesep}"
+        f"Supported formats: {SUPPORTED_OUTPUT_FORMATS}."
+        )
+
+
+def main(
+    run_dir: FilePath,
+    modules: list[int],
+    top_clusters: int,
+    format: Optional[ImgFormat],
+    scale: Optional[float],
+    inter: Optional[bool],
+    is_cleaned: Optional[bool],
+    offline: bool = False,
+    mode: Optional[str] = None,
+    ncores: Optional[int] = None,
+    self_contained: bool = False,
+    **kwargs: Any,
+) -> None:
+    """
+    Analyse CLI.
+
+    Parameters
+    ----------
+    run_dir : str or Path
+        Path to the original run directory.
+    modules : list of ints
+        List of the integer prefix of the modules to copy.
+    top_clusters : int
+        Number of clusters to be considered.
+    format : str
+        Produce images in the selected format.
+    scale : int
+        scale for images.
+    inter: bool
+        analyse only steps labelled as 'interactive'
+    is_cleaned: bool
+        is the directory going to be cleaned?
+    offline: bool
+        Should plots js functions be self-contained?
+    mode: str
+        mode of execution
+    ncores: int
+        number of cores to use
+    self_contained : bool
+        Should the analysis directory contain the models?
+    """
+    log.level = 20
+    log.info(
+        f"Running haddock3-analyse on {run_dir}, modules {modules}, "
+        f"with top_clusters = {top_clusters}"
+    )
+    # Validate output format
+    format = validate_format(format)
+
+    # Obtain starting working directory
+    ori_cwd = os.getcwd()
+    # modifying the parameters
+    default_capri = read_from_yaml_config(caprieval_params)
+    capri_dict = update_capri_dict(default_capri, kwargs)
+
+    os.chdir(run_dir)
+    # Create analysis folder
+    rundir_cwd = os.getcwd()
+    outdir = Path(ANA_FOLDER)
+    try:
+        outdir.mkdir(exist_ok=False)
+        log.info(f"Created directory: {str(outdir.resolve())}")
+    except FileExistsError:
+        log.warning(f"Directory {str(outdir.resolve())} already exists.")
+
+    # Reading steps
+    log.info("Reading input run directory")
+    # get the module folders from the run_dir input
+    sel_steps = get_module_steps_folders(Path("./"), modules)
+    if inter:
+        sel_steps = [st for st in sel_steps if st.endswith(INTER_STR)]
+    else:
+        sel_steps = [st for st in sel_steps if not st.endswith(INTER_STR)]
+    log.info(f"selected steps: {', '.join(sel_steps)}")
+
+    # analysis
+    good_folder_paths: list[Path] = []
+    bad_folder_paths: list[Path] = []
+    for step in sel_steps:
+        subfolder_name = f"{step}_analysis"
+        target_path = Path(subfolder_name)
+
+        # check if subfolder is already present
+        dest_path = Path(ANA_FOLDER, subfolder_name)
+        if dest_path.exists():
+            if len(os.listdir(dest_path)) != 0 and not inter:
+                log.warning(
+                    f"{dest_path} exists and is not empty. "
+                    "Skipping analysis..."
+                    )
+                continue
+            else:  # subfolder is empty or is interactive, remove it.
+                log.info(f"Removing folder {dest_path}.")
+                shutil.rmtree(dest_path)
+
+        # run the analysis
+        try:
+            analyse_step(
+                step,
+                Path("./"),
+                capri_dict,
+                target_path,
+                top_clusters,
+                format,
+                scale,
+                is_cleaned,
+                offline=offline,
+                mode=mode,
+                ncores=ncores,
+                self_contained=self_contained,
+                )
+        except Exception as e:
+            log.warning(
+                f"Could not execute the analysis for step {step}. "
+                f"The following error occurred: {e}"
+                )
+            bad_folder_paths.append(target_path)
+        else:
+            good_folder_paths.append(target_path)
+
+        # going back
+        os.chdir(rundir_cwd)
+
+    # moving files into analysis folder
+    if good_folder_paths != []:
+        log.info("moving files to analysis folder")
+        urls: list[str] = []
+        for directory in good_folder_paths:
+            shutil.move(directory, outdir)
+            url = f"- [{Path(directory, 'report.html')}](http://0.0.0.0:8000/{Path(directory, 'report.html')}) "  # noqa : E501
+            urls.append(url)
+        
+        # Adding instructions on how to setup the server
+        readme_fpath = Path(outdir, "README.md")
+        readme_fpath.write_text(
+            f"# Usage{os.linesep}{os.linesep}"
+            "To view structures or download the structure files, "
+            f"in a terminal run the command:{os.linesep}```bash{os.linesep}"
+            f"python -m http.server --directory .{os.linesep}```{os.linesep}"
+            f"And open the link following links in a web browser:{os.linesep}"
+            f"{os.linesep.join(urls)}{os.linesep}"
+            )
+        assert readme_fpath.exists()
+
+    if bad_folder_paths != []:
+        log.info("cancelling unsuccesful analysis folders")
+        for directory in bad_folder_paths:
+            if directory.exists():
+                shutil.rmtree(directory)
+
+    # substituting the correct paths in the capri_ss files
+    # after moving files into analysis folder
+    for directory in good_folder_paths:
+        ss_file = Path(outdir, directory, "capri_ss.tsv")
+        if ss_file.exists():
+            log.info(f"updating paths in {ss_file}")
+            update_paths(ss_file, "../", "../../")
+        report_file = Path(outdir, directory, "report.html")
+        log.info(f"View the results in {report_file}")
+        info_msg = (
+            "To view structures or download the structure files, "
+            f"in a terminal run the command: {os.linesep}"
+            f">python -m http.server --directory {rundir_cwd}{os.linesep}"
+            # "By default, http server runs on `http://0.0.0.0:8000/`. "
+            f"And open the link http://0.0.0.0:8000/{report_file} "
+            "in a web browser."
+            )
+        log.info(info_msg)
+    os.chdir(ori_cwd)
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_cfg.py

@@ -0,0 +1,236 @@
+"""
+Extract the default configuration file for each module.
+
+By default presents the parameters from the three expertise levels:
+    `basic`, `intermediate`, and `guru`.
+
+Usage::
+
+    haddock3-cfg  # prints only the general parametes
+    haddock3-cfg -g  # same as above
+    haddock3-cfg -m MODULE  # prints only the module parameters
+    haddock3-cfg -m MODULE -l LEVEL
+    haddock3-cfg -m topoaa -l all
+    haddock3-cfg -m rigidbody -l all -g  # prints the module and the globals
+"""
+import argparse
+import importlib
+import os
+import sys
+
+from pathlib import Path
+
+from haddock import config_expert_levels, core_path
+from haddock.core.typing import (
+    ArgumentParser,
+    Callable,
+    ExpertLevel,
+    Namespace,
+    Optional,
+)
+from haddock.modules import modules_category
+
+
+ap = argparse.ArgumentParser(
+    prog="HADDOCK3 config retriever",
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+ap.add_argument(
+    "-m",
+    dest="module",
+    help="The module for which you want to retrieve the default configuration.",
+    choices=sorted(modules_category.keys()),
+    default=None,
+)
+
+ap.add_argument(
+    "-l",
+    dest="explevel",
+    required=False,
+    help='The expertise level of the parameters. Defaults to "all".',
+    default="all",
+    choices=config_expert_levels + ("all",),
+)
+
+ap.add_argument(
+    "-g",
+    "--globals",
+    dest="global_params",
+    help="Add also the optional module's general parameters.",
+    action="store_true",
+)
+
+ap.add_argument(
+    "-d",
+    "--details",
+    dest="details",
+    help="Add detailed parameter description found in 'long'.",
+    action="store_true",
+    default=False,
+)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+# command-line client helper functions
+# load_args, cli, maincli
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = load_args(ap)
+
+    # I didn't want to to have the `--globals` param as a negative parameter
+    # ('store_false'). However, `module` and `globals` can't both be false.
+    # In order for the commands below performing the same:
+    #
+    # haddock3-cfg
+    # haddock3-cfg -g
+    #
+    # we need this quick if statement. Which basically adjust the argparse to
+    # the default values in the main function.
+    # @joaomcteixeira
+    if cmd.global_params is False and cmd.module is None:
+        cmd.global_params = True
+
+    main(**vars(cmd))
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(
+    module: Optional[str] = None,
+    explevel: str = "all",
+    global_params: bool = True,
+    details: bool = False,
+) -> None:
+    """
+    Extract the defaults in the form of a run configuration file.
+
+    Parameters
+    ----------
+    module : str or None
+        The module name to extract the defaults from.
+        If ``None`` given, we expect ``global_params`` to be ``True``,
+        otherwise nothing will be printed.
+
+    explevel : str
+        Filter the parameters according to the expert level. Output all
+        parameters that belong to the referred level or below. Choices
+        are: all, easy, expert, and guru.
+
+    global_params : bool
+        Whether to add the module's general global parameter. If
+        ``True`` and ``module`` is ``None``, outputs only the general
+        parameters.
+
+    details : bool
+        Whether to add the 'long' description of each parameter.
+    """
+    from haddock import modules_defaults_path
+    from haddock.gear.yaml2cfg import yaml2cfg_text
+    from haddock.libs.libio import read_from_yaml
+
+    new_config = ""
+
+    if global_params:
+        # Read general parameters
+        general_cfg = read_from_yaml(modules_defaults_path)
+        general_params_str = yaml2cfg_text(
+            general_cfg,
+            module=None,
+            explevel="all",
+            details=details,
+            )
+        general_comment = os.linesep.join(
+            (
+                "#" * 50,
+                "# The parameters below are optional parameters. ",
+                "# They can either be used as global parameters or as part ",
+                "# of the module's parameters",
+                "#" * 50,
+                )
+            )
+
+        # Read mandatory parmeters
+        mandatory_cfg_path = Path(core_path, "mandatory.yaml")
+        general_mandatory_cfg = read_from_yaml(mandatory_cfg_path)
+        general_mandatory_params_str = yaml2cfg_text(
+            general_mandatory_cfg,
+            module=None,
+            explevel="all",
+            details=details,
+            mandatory_param=True,
+            )
+        mandatory_comment = os.linesep.join(
+            (
+                "#" * 50,
+                "# The parameters below are mandatory parameters.",
+                "# They must be specified in your configuration file!",
+                "#" * 50,
+                )
+            )
+
+        # Read optional parameters
+        optional_cfg_path = Path(core_path, "optional.yaml")
+        general_optional_cfg = read_from_yaml(optional_cfg_path)
+        general_optional_params_str = yaml2cfg_text(
+            general_optional_cfg,
+            module=None,
+            explevel="all",
+            details=details,
+            )
+        optional_comment = os.linesep.join(
+            (
+                "#" * 50,
+                "# The parameters below are optional global parameters.",
+                "#" * 50,
+                )
+            )
+        # Concatenate all of them
+        new_config = os.linesep.join(
+            (
+                mandatory_comment,
+                general_mandatory_params_str,
+                optional_comment,
+                general_optional_params_str,
+                general_comment,
+                general_params_str,
+                )
+            )
+
+    if module:
+        module_name = ".".join(
+            (
+                "haddock",
+                "modules",
+                modules_category[module],
+                module,
+            )
+        )
+
+        module_lib = importlib.import_module(module_name)
+        cfg = module_lib.DEFAULT_CONFIG
+
+        ycfg = read_from_yaml(cfg)
+        module_config = yaml2cfg_text(ycfg, module, explevel, details=details)
+
+        new_config = os.linesep.join((new_config, module_config))
+
+    sys.stdout.write(new_config)
+
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_clean.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Clean the output of an HADDOCK3 run directory.
+
+The clean process performs file archiving and file compressing
+operations.
+
+All `.inp` and `.out` files are deleted except for the first one, which
+is compressed to `.gz`. On the other hand, all `.seed` and `.con` files
+are compressed and archived to `.tgz` files. Finally, `.pdb` and `.psf`
+files are compressed to `.gz`.
+
+The <run_directory> can either be a whole HADDOCK3 run folder or a
+specific folder of the workflow step. <ncores> defines the number of
+threads to use; by default uses a single core.
+
+Usage::
+
+    haddock3-clean -h
+    haddock3-clean <run_directory>
+    haddock3-clean run1
+    haddock3-clean run1/1_rigidbody
+    haddock3-clean run1 -n  # uses all cores
+    haddock3-clean run1 -n 2  # uses 2 cores
+"""
+import argparse
+import sys
+
+from haddock.core.typing import (
+    ArgumentParser,
+    Callable,
+    FilePath,
+    Namespace,
+    Optional,
+)
+from haddock.libs import libcli
+
+
+# Command line interface parser
+ap = argparse.ArgumentParser(
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+libcli.add_rundir_arg(ap)
+libcli.add_ncores_arg(ap)
+libcli.add_version_arg(ap)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = load_args(ap)
+    main(**vars(cmd))
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(run_dir: FilePath, ncores: Optional[int] = 1) -> None:
+    """
+    Clean a HADDOCK3 directory.
+
+    Usually, this concerns compressing and archiving files (see below).
+
+    Parameters
+    ----------
+    run_dir : str or :external:py:class:`pathlib.Path`.
+        The path to the run directory or to a folder of a specific step
+        of the workflow.
+
+    ncores : int, or None
+        The number of cores to use. If ``None``, use all possible threads.
+        Defaults to 1.
+
+    See Also
+    --------
+    `haddock.gear.clean_steps`
+    """
+    # anti-pattern to speed up CLI initiation
+    from pathlib import Path
+
+    from haddock import log
+    from haddock.gear.clean_steps import clean_output
+    from haddock.libs.libtimer import log_time
+    from haddock.libs.libutil import parse_ncores
+    from haddock.modules import get_module_steps_folders, is_step_folder
+
+    log.info(f"Compressing {str(run_dir)!r} folder")
+    ncores = parse_ncores(ncores)
+
+    if is_step_folder(run_dir):
+        with log_time("compressing took"):
+            clean_output(run_dir, ncores)
+
+    else:
+        step_folders = get_module_steps_folders(run_dir)
+        for folder in step_folders:
+            with log_time("compressing took"):
+                clean_output(Path(run_dir, folder), ncores)
+
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_cp.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Copy steps to a new run.
+
+In HADDOCK3 you can copy successful steps from a run directory to a new
+directory and use them as starting points for a new run.
+
+Considering the example::
+
+    run1/
+        0_topoaa/
+        1_rigidbody/
+        2_caprieval/
+        3_seletop/
+        4_flexref/
+        (etc...)
+
+You can use `4_flexref` step folder as a starting point for a new run.
+
+USAGE::
+
+    haddock3-copy -r <run_dir> -m <num_modules> -o <new_run_dir>
+    haddock3-copy -r run1 -m 0 4 -o run2
+
+Where, ``-m 0 4`` will copy ``0_topoaa`` and ``4_flexref`` to <new_run_dir>.
+
+**Note:** If the new run uses CNS-dependent modules, you **also need**
+to copy the folder corresponding to the initial topology creation (the
+`topoaa` module).
+
+`haddock3-copy` will also copy the corresponding files in the `data`
+directory and update the file contents in the copied folder such that
+the information on the run directory and the new step folder names match.
+The output result of the above commands is::
+
+    run2/
+        0_topoaa/
+        1_flexref/
+
+Following, you can use the `haddock3` command with the `--extend-run`
+option to continue a new run::
+
+    haddock3 new-config.cfg --extend-run run2
+"""
+import argparse
+import os
+import sys
+
+from haddock import log
+from haddock.core.typing import ArgumentParser, Callable, FilePath, Namespace
+from haddock.libs.libcli import add_version_arg
+
+
+# Command line interface parser
+ap = argparse.ArgumentParser(
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+ap.add_argument(
+    "-r",
+    "--run-dir",
+    help="The input run directory.",
+    required=True,
+    )
+
+ap.add_argument(
+    "-m",
+    "--modules",
+    nargs="+",
+    help="The IDs of the steps to copy (separated by spaces).",
+    required=True,
+    type=int,
+    )
+
+ap.add_argument(
+    "-o",
+    "--output",
+    help="The new run directory.",
+    required=True,
+    )
+
+add_version_arg(ap)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = load_args(ap)
+    main(**vars(cmd))
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(run_dir: FilePath, modules: list[int], output: FilePath) -> None:
+    """
+    Copy steps from a run directory to a new run directory.
+
+    Also updates paths references in step files accordingly.
+
+    Parameters
+    ----------
+    run_dir : str or Path
+        Path to the original run directory.
+
+    modules : list of ints
+        List of the integer prefix of the modules to copy.
+
+    output : str or Path
+        The new run directory to create and where to copy the steps.
+    """
+    from pathlib import Path
+
+    from haddock.gear.clean_steps import unpack_compressed_and_archived_files
+    from haddock.gear.extend_run import (
+        copy_renum_step_folders,
+        update_contents_of_new_steps,
+        )
+    from haddock.gear.zerofill import zero_fill
+    from haddock.modules import get_module_steps_folders
+
+    log.info("Reading input run directory")
+    # get the module folders from the run_dir input
+    steps = get_module_steps_folders(run_dir)
+    selected_steps = [steps[i] for i in range(len(steps)) if i in modules]
+    log.info(f"selected steps: {', '.join(selected_steps)}")
+
+    # make new run dir
+    outdir = Path(output)
+    try:
+        outdir.mkdir(parents=True, exist_ok=False)
+    except FileExistsError:
+        log.error(f"Directory {str(outdir.resolve())} already exists.")
+        sys.exit(1)
+    log.info(f"Created directory: {str(outdir.resolve())}")
+
+    # copy folders over
+    zero_fill.set_zerofill_number(len(selected_steps))
+    new_step_folder = copy_renum_step_folders(run_dir, outdir, selected_steps)
+
+    # copy data folders
+    # `data_steps` are selected to avoid FileNotFoundError because some steps
+    # do not have a `data` folder.
+    # See https://github.com/haddocking/haddock3/issues/559
+    data_steps = [
+        step for step in selected_steps
+        if os.path.exists(Path(run_dir, "data", step))
+        ]
+    copy_renum_step_folders(
+        Path(run_dir, "data"),
+        Path(outdir, "data"),
+        data_steps,
+        )
+
+    # update step names in files
+    # update run dir names in files
+    unpack_compressed_and_archived_files(
+        new_step_folder,
+        ncores=1,
+        dec_all=True,
+        )
+    update_contents_of_new_steps(selected_steps, run_dir, outdir)
+
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_dmn.py

@@ -0,0 +1,333 @@
+r"""
+HADDOCK3 benchmark submission daemon.
+
+For more information read our benchmark tutorial at `docs/benchmark.tut`
+in HADDOCK3 repository site: https://github.com/haddocking/haddock3::
+
+   (_) L|J
+   (")  |
+   /_\--|
+ _/\ /  |
+   _W_  |
+
+Usage::
+
+    haddock3-dmn -h
+    haddock3-dmn <benchmark folder>  --job-limit <num> [OPTIONS]
+"""
+import argparse
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from haddock.core.typing import ArgumentParser, Callable, Namespace, Optional
+
+
+workload_manager_launch = {
+    "slurm": "sbatch",
+    "torque": "qsub",
+}
+"""options for the different job queue systems supported"""
+
+
+# prepares client arguments
+ap = argparse.ArgumentParser(
+    prog="HADDOCK3 benchmark submission daemon.",
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+ap.add_argument(
+    "benchmark_path",
+    help="Path to the benchmark folder as prepared by `haddock3-bm` interface.",
+    type=Path,
+)
+
+ap.add_argument(
+    "--job-limit",
+    dest="job_limit",
+    help="How many jobs should run at the same time. Default: 10",
+    default=10,
+    type=int,
+)
+
+ap.add_argument(
+    "--job-sys",
+    dest="manager",
+    help="The system where the jobs will be run. Default `slurm`.",
+    choices=tuple(workload_manager_launch.keys()),
+    default="slurm",
+)
+
+ap.add_argument(
+    "--restart",
+    help="Restart the RUNNING jobs. DONE jobs won't be touched.",
+    action="store_true",
+)
+
+ap.add_argument(
+    "--sort-first",
+    dest="sort_first",
+    help=(
+        "Sort jobs by size in ascending order. If not given jobs are order by "
+        "size in descending order: the biggest first."
+    ),
+    action="store_true",
+)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+class Job:
+    """
+    Job task.
+
+    Controls the status of each job.
+
+    Parameters
+    ----------
+    job_f : pathlib.Path
+        The path to the job file.
+
+    launch_command : str
+        The command to launch the job. For example `sbatch`.
+    """
+
+    def __init__(self, job_f: Path, launch_command: str) -> None:
+        self.job_filename = job_f
+
+        self.launch_command = launch_command
+
+        # previous jog path
+        job_stem = job_f.stem
+        self.job_run_folder = Path(job_f.parents[1], f"run-{job_stem}")
+
+        self.check_done = Path(self.job_run_folder, "DONE")
+        self.check_running = Path(self.job_run_folder, "RUNNING")
+        self.check_available = Path(self.job_run_folder, "AVAILABLE")
+        self.check_fail = Path(self.job_run_folder, "FAIL")
+        self.status = None
+
+        self.status_files = [
+            self.check_done,
+            self.check_running,
+            self.check_fail,
+            self.check_available,
+        ]
+
+    def get_status(self) -> Optional[str]:
+        """
+        Get job status.
+
+        The job status depends on the present of files: `AVAILABLE`,
+        `RUNNING`, `DONE`, and `FAIL` created by `haddock-bm` jobs.
+
+        Status is assigned to `self.status` and returned.
+        """
+        for _file in self.status_files:
+            if _file.exists():
+                self.status = _file.stem  # type: ignore
+                break
+        return self.status
+
+    def submit(self) -> None:
+        """
+        Submit job.
+
+        Run command `$launch_command $job_filename`.
+        """
+        subprocess.run(cmds := [self.launch_command, str(self.job_filename)])
+        print("Job sent: ", cmds)
+
+    def restart(self) -> None:
+        """
+        Restart the status of the job to `AVAILABLE`.
+
+        Does this by removing all status files and creating the file
+        `AVAILABLE`.
+        """
+        self.check_done.unlink(missing_ok=True)
+        self.check_running.unlink(missing_ok=True)
+        self.check_fail.unlink(missing_ok=True)
+        self.check_available.touch(exist_ok=True)
+
+
+def get_current_jobs(grep: str = "BM5") -> int:
+    """
+    Get current number of jobs for which job-name has the `grep` word.
+
+    List of jobs is retrieve using the command `qstat`.
+
+    Parameters
+    ----------
+    grep : str
+        The string to search job-names for.
+
+    Return
+    ------
+    int
+        The number of jobs with the word `grep` in their name.
+    """
+    concurrent_cmd = "qstat -a | awk '{print $4}' | grep " + grep + " | wc -l"
+    p = subprocess.Popen(
+        concurrent_cmd,
+        shell=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+    output = p.communicate()[0]
+    njobs = int(output.decode("utf-8"))
+    print(f"Found {njobs} in the queue.")
+    return njobs
+
+
+def calc_size(job_path: Path) -> int:
+    """
+    Calculate the size of the job.
+
+    Expects the job file to be in a folder structure as defined by
+    `haddock3-bm`.
+
+    The size of the jobs is defined by the number of carbon-alpha lines
+    in the `target.pdb` file.
+    """
+    target_pdb = Path(job_path.parents[1], "input", "target.pdb")
+    lines = target_pdb.read_text().split(os.linesep)
+    size = sum(1 for line in lines if line[11:16].strip() == "CA")
+    return size
+
+
+def filter_by_status(job_list: list[Job], status: str = "AVAILABLE") -> list[Job]:
+    """
+    Filter jobs by their status.
+
+    Only jobs with `status` are accepted.
+
+    Parameters
+    ----------
+    job_list : list of Job objects.
+
+    Returns
+    -------
+    list
+        The list with the `Job`s with matching `status`.
+    """
+    jobs = [j for j in job_list if j.get_status() == status]
+    print(f"Number of {status} jobs: {len(jobs)}.")
+    return jobs
+
+
+# command-line client helper functions
+# load_args, cli, maincli
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = load_args(ap)
+    main(**vars(cmd))
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(
+    benchmark_path: Path,
+    job_limit: int = 10,
+    manager: str = "slurm",
+    restart: bool = False,
+    sort_first: bool = False,
+) -> None:
+    """
+    Execute the benchmark daemon.
+
+    The parameters defined here are the same as defined in the client
+    arguments.
+
+    This is the main function of the client. If you want to run the
+    daemon withOUT using the command line and instead importing its
+    functionalities and setting it up from another pythong script, you
+    should import this function.
+
+    >>> from haddock.clis.cli_dmn import main
+
+    Parameters
+    ----------
+    benchmark_path : pathlib.Path
+        The path of the benchmark folder as created by the `haddock3-bm`
+        interface.
+
+    job_limit : int
+        The max number of jobs to send to the queue.
+
+    manager : str
+        A key to the `workload_manager_launch` dictionary. Selects the queue
+        management system.
+
+    restart : bool
+        Whether to restart the `RUNNING` jobs that might have been halted
+        in previous daemon runs. Defaults to False.
+
+    sort_first : bool
+        Whether to sort jobs by their size in ascending manner. That is,
+        the sorted jobs first. Defaults to False, the longer first.
+    """
+    # lists of all the job files in the benchmark_path folder
+    job_list = list(benchmark_path.glob("*/jobs/*.job"))
+
+    # breaks if no jobs are found
+    if not job_list:
+        sys.exit("+ ERROR! No jobs found in folder: {str(benchmark_path)!r}")
+
+    # sorts the job list
+    job_list.sort(key=calc_size, reverse=not (sort_first))  # noqa: E275
+
+    # create the job objects according to the queue managing systme
+    _jobsys = workload_manager_launch[manager]
+    jobs = [Job(j, _jobsys) for j in job_list]
+
+    # restart previously (halted) `RUNNING` jobs - if selected.
+    if restart:
+        running_jobs = filter_by_status(jobs, status="RUNNING")
+        for _job in running_jobs:
+            _job.restart()
+
+    # Lists the available jobs (those with status `AVAILABLE`)
+    available_jobs = filter_by_status(jobs)
+
+    # runs the daemon loop, only if there are available jobs :-)
+    while available_jobs:
+        # get the number of available queue slots according to the
+        # job limit parameter
+        #
+        # 0 is added to avoid going to negative values in case a job
+        # had been manually submitted.
+        empty_slots = max(0, job_limit - get_current_jobs())
+        print("empty slots: ", empty_slots)
+
+        # send jobs if there are empty slots
+        for i in range(empty_slots):
+            available_jobs[i].submit()
+            time.sleep(5)
+
+        # chill before repeating the process.
+        print("chilling for 120 seconds...")
+        time.sleep(120)
+
+        # refreshes the available_jobs list
+        available_jobs = filter_by_status(jobs)
+
+    # done
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_mpi.py

@@ -0,0 +1,123 @@
+"""
+MPI-wrapper for executing pickled CNSJobs created by libmpi.
+
+This was developed for use of lbimpi but it might be useful in some specific
+ scenario as a cli.
+
+For more information please refer to the README.md in the examples folder.
+
+Usage::
+
+    haddock3-mpitask -h
+    haddock3-mpitask tasks.pkl
+"""
+
+import argparse
+import pickle
+import sys
+
+from haddock.core.typing import (
+    AnyT,
+    ArgumentParser,
+    Callable,
+    FilePath,
+    Namespace,
+)
+from haddock.libs.libsubprocess import CNSJob
+
+
+# Note! ########################################################################################
+# It's important to not define `MPI` and `COMM` directly but to use the `get_mpi`
+#  function to ensure that the MPI module is only loaded when needed.
+# This is important for testing purposes, and this CLI should further be refactored to not use
+#  global variables.
+MPI = None
+COMM = None
+# Note! ########################################################################################
+
+
+def get_mpi():
+    """Lazy load MPI and COMM."""
+    global MPI, COMM
+    if MPI is None:
+        try:
+            from mpi4py import MPI as _MPI
+
+            MPI = _MPI
+            COMM = MPI.COMM_WORLD
+        except ImportError as e:
+            _msg = (
+                f"{e} - To run this cli you must have mpi4py and "
+                "OpenMPI installed in the system"
+            )
+            sys.exit(_msg)
+    return MPI, COMM
+
+
+def split_tasks(task_l: list[AnyT], n: int) -> list[list[AnyT]]:
+    """Split tasks into equal lenght chunks."""
+    return [task_l[_i::n] for _i in range(n)]
+
+
+# ========================================================================#
+# helper functions to enhance flexibility and modularity of the CLIs
+
+ap = argparse.ArgumentParser(
+    prog="MPI-wrapper for executing pickled CNSJobs created by libmpi",
+    description=__doc__,
+)
+
+ap.add_argument(
+    "pickled_tasks",
+    help="The input pickled tasks path",
+)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = load_args(ap)
+    main(**vars(cmd))
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+# ========================================================================#
+
+
+def main(pickled_tasks: FilePath) -> None:
+    """Execute the tasks."""
+    MPI, COMM = get_mpi()
+    if COMM.rank == 0:
+        with open(pickled_tasks, "rb") as pkl:
+            tasks = pickle.load(pkl)
+        mpi_jobs = split_tasks(tasks, COMM.size)
+    else:
+        mpi_jobs = None
+
+    jobs: list[CNSJob] = COMM.scatter(mpi_jobs, root=0)
+
+    results: list[FilePath] = []
+    for job in jobs:
+        job.run()
+        # check if the job has an input file
+        if hasattr(job, "input_file"):
+            results.append(job.input_file)
+
+    # COMM.Barrier()
+    # results = MPI.COMM_WORLD.gather(results, root=0)
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_pp.py

@@ -0,0 +1,168 @@
+"""
+HADDOCK3 PDB preprocessing client.
+
+Process PDB files for agreement with HADDOCK3 requirements. Follows the
+logic implemented in the :py:mod:`haddock.gear.preprocessing`. See
+documentation pages for more details.
+
+You can use the `--dry` option to report on the performed changes
+without actually performing the changes.
+
+Corrected PDBs are saved to new files named after the `--suffix` option.
+Original PDBs are never overwritten, unless `--suffix` is given an empty
+string.
+
+You can pass multiple PDB files to the command-line.
+
+Usage::
+
+    haddock-pp file1.pdb file2.pdb
+    haddock-pp file1.pdb file2.pdb --suffix _new
+    haddock-pp file1.pdb file2.pdb --dry
+"""
+import argparse
+import sys
+from pathlib import Path
+
+from haddock import log
+from haddock.core.typing import (
+    ArgumentParser,
+    Callable,
+    FilePath,
+    Namespace,
+    Optional,
+)
+from haddock.gear.preprocessing import process_pdbs, read_additional_residues
+from haddock.libs.libcli import add_output_dir_arg
+from haddock.libs.libio import add_suffix_to_files, save_lines_to_files
+
+
+SUFFIX_DEFAULT = "_processed"
+
+ap = argparse.ArgumentParser(
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+ap.add_argument(
+    "pdb_files",
+    help="Input PDB files.",
+    nargs="+",
+)
+
+ap.add_argument(
+    "-d",
+    "--dry",
+    help="Perform a dry run. Informs changes without modifying files.",
+    action="store_true",
+)
+
+ap.add_argument(
+    "-t",
+    "--topfile",
+    help="Additional .top files.",
+    nargs="*",
+)
+
+ap.add_argument(
+    "-s",
+    "--suffix",
+    help=f"Suffix to output files. Defaults to {SUFFIX_DEFAULT!r}",
+    default=SUFFIX_DEFAULT,
+)
+
+add_output_dir_arg(ap)
+
+
+# client helper functions
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = vars(load_args(ap))
+    # I use this `pop` structure to maintain the unpacking argument in
+    # the `main` function because I foresee the `main` to be used from
+    # other parts of the software(s)
+    main(*cmd.pop("pdb_files"), **cmd)
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(
+    *pdb_files: FilePath,
+    dry: bool = False,
+    output_directory: Optional[FilePath] = None,
+    suffix: str = SUFFIX_DEFAULT,
+    topfile: Optional[FilePath] = None,
+) -> None:
+    """
+    Process PDB files.
+
+    Parameters
+    ----------
+    dry : bool
+        Whether to perform a dry test only.
+
+    output_directory : str or ``pathlib.Path``
+        The directory where to save the output. Defaults to the current
+        working directory.
+
+    suffix : str
+        The suffix to append to the new files. Will be added before the
+        file extension. Original extension will be kept.
+
+    topfile : str or ``pathlib.Path``
+        The path to an additional HADDOCK3 topology file.
+    """
+    log.info("Starting processing PDB files.")
+    log.info(f"Total number of PDB files: {len(pdb_files)}")
+
+    if dry:
+        log.info(
+            "You selected the `--dry` option. No new files will be created. "
+            "A report of the changes that would be performed in the PDB files "
+            "will be printed."
+        )
+
+    new_residues = read_additional_residues(topfile) if topfile else None
+
+    log.info("Processing the PDB files... " "This may take a bit if there are many.")
+
+    processed_pdbs = process_pdbs(
+        *pdb_files,
+        dry=dry,
+        user_supported_residues=new_residues,
+    )
+
+    if dry:
+        log.info("Everything done. Exiting...")
+        sys.exit(0)
+
+    log.info("Finished processing PDBs. Saving to disk...")
+    if output_directory is None:
+        output_directory = Path.cwd()
+    else:
+        output_directory = Path(output_directory)
+    log.info("Output dir: {!r}".format(str(output_directory)))
+    output_directory.mkdir(parents=True, exist_ok=True)
+
+    pdb_names = (Path(output_directory, Path(pdb).name) for pdb in pdb_files)
+    out_files = add_suffix_to_files(pdb_names, suffix)
+    save_lines_to_files(out_files, processed_pdbs)
+
+    log.info("Everything done. Exiting...")
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_re.py

@@ -0,0 +1,60 @@
+"""
+HADDOCK 3.0 CLI for interactive tasks.
+"""
+import argparse
+import sys
+import os
+
+from haddock.clis.re.clustfcc import add_clustfcc_arguments, reclustfcc
+from haddock.clis.re.clustrmsd import add_clustrmsd_arguments, reclustrmsd
+from haddock.clis.re.score import add_rescore_arguments, rescore
+
+# Command line interface parser
+ap = argparse.ArgumentParser(
+    prog="haddock3-re",
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+subparsers = ap.add_subparsers(title='subcommands',
+                               help='valid subcommands',
+                              )
+
+# score subcommand
+rescore_subcommand = subparsers.add_parser('score')
+rescore_subcommand.set_defaults(func=rescore)
+rescore_subcommand = add_rescore_arguments(rescore_subcommand)
+# clustrmsd subcommand
+clustrmsd_subcommand = subparsers.add_parser('clustrmsd')
+clustrmsd_subcommand.set_defaults(func=reclustrmsd)
+clustrmsd_subcommand = add_clustrmsd_arguments(clustrmsd_subcommand)
+# clustfcc subcommand
+clustfcc_subcommand = subparsers.add_parser('clustfcc')
+clustfcc_subcommand.set_defaults(func=reclustfcc)
+clustfcc_subcommand = add_clustfcc_arguments(clustfcc_subcommand)
+
+
+def _ap():
+    return ap
+
+
+def load_args(ap):
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def maincli():
+    """Execute main client."""
+    args = ap.parse_args()
+    cmd = vars(load_args(ap))
+    if "func" not in cmd.keys():
+        sys.stderr.write(f"Error: no subcommand given.{os.linesep}")
+        ap.print_help()
+        sys.exit(1)
+    else:
+        cmd.pop("func")
+    args.func(**cmd)
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_restraints.py

@@ -0,0 +1,143 @@
+"""
+HADDOCK3 CLI for restraints-related tasks.
+
+DISCLAIMER: these scripts have been ported from old code and are not
+optimized for code quality and performance. They are provided as a convenience
+for the user.
+
+USAGE::
+
+    haddock3-restraints <TASK_NAME> <TASK_ARGS>
+
+For the list of available tasks, run::
+
+    haddock3-restraints -h
+
+For the list of arguments for a given task, run::
+
+    haddock3-restraints <TASK_NAME> -h
+"""
+
+import argparse
+import sys
+
+from haddock import log
+from haddock.clis.restraints.active_passive_to_ambig import (
+    actpass_to_ambig,
+    add_actpass_to_ambig_arguments,
+    )
+from haddock.clis.restraints.calc_accessibility import (
+    add_calc_accessibility_arguments,
+    calc_accessibility,
+    )
+from haddock.clis.restraints.passive_from_active import (
+    add_pass_from_act_arguments,
+    passive_from_active,
+    )
+from haddock.clis.restraints.restrain_bodies import (
+    add_restrain_bodies_arguments,
+    restrain_bodies,
+    )
+from haddock.clis.restraints.validate_tbl import (
+    add_validate_tbl_arguments,
+    validate_tbl,
+    )
+from haddock.clis.restraints.z_surface_restraints import (
+    add_z_surf_restraints_arguments,
+    gen_z_surface_restraints,
+    )
+from haddock.clis.restraints.random_removal import (
+    add_rand_removal_arguments,
+    main as random_removal,
+    )
+from haddock.clis.restraints.restrain_ligand import (
+    add_restrain_ligand_arguments,
+    main as restrain_ligand,
+    )
+
+# Command line interface parser
+ap = argparse.ArgumentParser(
+    prog="haddock3-restraints",
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+subparsers = ap.add_subparsers(
+    title="subcommands",
+    description="valid subcommands",
+    help="additional help",
+)
+
+# restrain_bodies subcommand
+restrain_bodies_subcommand = subparsers.add_parser("restrain_bodies")
+restrain_bodies_subcommand.set_defaults(func=restrain_bodies)
+restrain_bodies_subcommand = add_restrain_bodies_arguments(restrain_bodies_subcommand)
+
+# passive_from_active subcommand
+pass_from_act_subcommand = subparsers.add_parser("passive_from_active")
+pass_from_act_subcommand.set_defaults(func=passive_from_active)
+pass_from_act_subcommand = add_pass_from_act_arguments(pass_from_act_subcommand)
+
+# validate_tbl subcommand
+validate_tbl_subcommand = subparsers.add_parser("validate_tbl")
+validate_tbl_subcommand.set_defaults(func=validate_tbl)
+validate_tbl_subcommand = add_validate_tbl_arguments(validate_tbl_subcommand)
+
+# active_passive_to_ambig subcommand
+actpass_to_ambig_subcommand = subparsers.add_parser("active_passive_to_ambig")
+actpass_to_ambig_subcommand.set_defaults(func=actpass_to_ambig)
+actpass_to_ambig_subcommand = add_actpass_to_ambig_arguments(
+    actpass_to_ambig_subcommand
+)
+
+# calc_accessibility subcommand
+calc_accessibility_subcommand = subparsers.add_parser("calc_accessibility")
+calc_accessibility_subcommand.set_defaults(func=calc_accessibility)
+calc_accessibility_subcommand = add_calc_accessibility_arguments(
+    calc_accessibility_subcommand
+)
+
+# z_surface_restraints subcommand
+z_surface_restraints_subcommand = subparsers.add_parser("z_surface_restraints")
+z_surface_restraints_subcommand.set_defaults(func=gen_z_surface_restraints)
+z_surface_restraints_subcommand = add_z_surf_restraints_arguments(
+    z_surface_restraints_subcommand
+)
+
+# random_removal subcommand
+restraints_random_removal_subcommand = subparsers.add_parser("random_removal")
+restraints_random_removal_subcommand.set_defaults(func=random_removal)
+restraints_random_removal_subcommand = add_rand_removal_arguments(
+    restraints_random_removal_subcommand
+)
+
+# restrain_ligand subcommand
+restraints_restrain_ligand_subcommand = subparsers.add_parser("restrain_ligand")
+restraints_restrain_ligand_subcommand.set_defaults(func=restrain_ligand)
+restraints_restrain_ligand_subcommand = add_restrain_ligand_arguments(
+    restraints_restrain_ligand_subcommand
+)
+
+
+def _ap():
+    return ap
+
+
+def load_args(ap):
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def maincli():
+    """Execute main client."""
+    args = ap.parse_args()
+    cmd = vars(load_args(ap))
+    try:
+        cmd.pop("func")
+    except KeyError:
+        sys.exit(ap.print_help())
+    args.func(**cmd)
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_score.py

@@ -0,0 +1,300 @@
+"""
+A simple tool to calculate the HADDOCK-score of a complex.
+
+You can pass to the command-line any parameter accepted by the `emscoring`
+module. For this, use the ``-p`` option writing the name of the parameters
+followed by the desired value. Write booleans with capital letter.
+
+Use the ``haddock3-cfg`` command-line to obtain the list of parameters for
+the ``emscoring`` module.
+
+Usage::
+
+    haddock3-score complex.pdb
+    haddock3-score complex.pdb -p nemsteps 50
+    haddock3-score complex.pdb -p nemsteps 50 w_air 1
+    haddock3-score complex.pdb -p nemsteps 50 w_air 1 electflag True
+
+"""
+import argparse
+import sys
+import tempfile
+
+from haddock.core.typing import (
+    Any,
+    ArgumentParser,
+    Callable,
+    FilePath,
+    Namespace,
+    )
+from haddock.libs.libcli import _ParamsToDict
+
+
+ap = argparse.ArgumentParser(
+    prog="haddock3-score",
+    description=__doc__,
+    )
+
+ap.add_argument("pdb_file", help="Input PDB file")
+
+ap.add_argument(
+    "--run_dir",
+    default="haddock-score-client",
+    type=str,
+    required=False,
+    help="Run directory name.",
+    )
+
+ap.add_argument(
+    "--full",
+    action="store_true",
+    help="Print all energy components",
+    )
+
+ap.add_argument(
+    "--outputpdb",
+    action="store_true",
+    help="Save the output PDB file (minimized structure)",
+    )
+
+ap.add_argument(
+    "--outputpsf",
+    action="store_true",
+    help="Save the output PSF file (topology)",
+    )
+
+ap.add_argument(
+    "-k" "--keep-all",
+    dest="keep_all",
+    action="store_true",
+    help="Keep the whole run folder.",
+    )
+
+ap.add_argument(
+    "-p",
+    "--other-params",
+    dest="other_params",
+    help=(
+        "Any other parameter of the `emscoring` module. "
+        "For example: -p nemsteps 1000. You can give any number of "
+        "parameters."
+    ),
+    action=_ParamsToDict,
+    default={},
+    nargs="*",
+    )
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = vars(load_args(ap))
+    kwargs = cmd.pop("other_params")
+    main(**cmd, **kwargs)
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(
+        pdb_file: FilePath,
+        run_dir: FilePath,
+        full: bool = False,
+        outputpdb: bool = False,
+        outputpsf: bool = False,
+        keep_all: bool = False,
+        **kwargs: Any,
+        ) -> None:
+    """
+    Calculate the score of a complex using the ``emscoring`` module.
+
+    Parameters
+    ----------
+    pdb_file : str or pathlib.Path
+        The path to the PDB containing the complex.
+
+    full : bool
+        Print all energy components.
+
+    outputpdb : bool
+        Save the PDB file resulting from the scoring calculation.
+
+    outputpsf : bool
+        Save  the PSF file resulting from the scoring calculation; this
+        is the CNS topology created before running the calculation.
+
+    keep_all : bool
+        Keep the whole temporary run folder. ``haddock3-score`` creates
+        a temporary run folder where the calculations are performed. If
+        ``keep_all`` is True, this folder is **not** deleted after when
+        the calculation finishes.
+
+    kwargs : any
+        Any additional arguments that will be passed to the ``emscoring``
+        module.
+    """
+    import os
+    import logging
+    import shutil
+    from contextlib import suppress
+    from pathlib import Path
+
+    from haddock import log, EmptyPath
+    from haddock.gear.haddockmodel import HaddockModel
+    from haddock.gear.yaml2cfg import read_from_yaml_config
+    from haddock.gear.zerofill import zero_fill
+    from haddock.libs.libio import working_directory
+    from haddock.libs.libworkflow import WorkflowManager
+    from haddock.modules.scoring.emscoring import DEFAULT_CONFIG
+
+    log.setLevel(logging.ERROR)
+
+    input_pdb = Path(pdb_file).resolve()
+    if not input_pdb.exists():
+        sys.exit(f"* ERROR * Input PDB file {str(input_pdb)!r} does not exist")
+
+    # config all parameters are correctly spelled.
+    default_emscoring = read_from_yaml_config(DEFAULT_CONFIG)
+    ems_dict = default_emscoring.copy()
+    n_warnings = 0
+    for param, value in kwargs.items():
+        # Check if the parameter name is in the emscoring module ones
+        if param not in default_emscoring:
+            sys.exit(
+                f"* ERROR * Parameter {param!r} is not a "
+                f"valid `emscoring` parameter.{os.linesep}"
+                "Valid emscoring parameters are: "
+                f"{', '.join(sorted(default_emscoring))}"
+                )
+        # Compare the user-given value to the default one
+        if value != default_emscoring[param]:
+            print(
+                f"* ATTENTION * Value ({value}) of parameter {param} "
+                f"different from default ({default_emscoring[param]})"
+            )
+            # get the type of default value
+            default_type = type(default_emscoring[param])
+            # cast the value to the same type
+            if default_type == bool:
+                if value.lower() not in ["true", "false"]:
+                    sys.exit(f"* ERROR * Boolean parameter {param} should be True or False")
+                value = value.lower() == "true"
+            elif param.endswith("_fname"):
+                value = EmptyPath() if str(value) == "" else Path(value).resolve()
+            else:
+                value = default_type(value)
+            ems_dict[param] = value
+            n_warnings += 1
+    if n_warnings != 0:
+        print(
+            "* ATTENTION * Non-default parameter values were used. "
+            "They should be properly reported if the output "
+            "data are used for publication."
+            )
+        print(f"used emscoring parameters: {ems_dict}")
+
+    # create run directory
+    run_dir = Path(run_dir)
+    with suppress(FileNotFoundError):
+        shutil.rmtree(run_dir)
+    run_dir.mkdir()
+    zero_fill.set_zerofill_number(2)
+
+    # create temporary file
+    with tempfile.NamedTemporaryFile(prefix=input_pdb.stem, suffix=".pdb") as tmp:
+
+        # create a copy of the input pdb
+        input_pdb_copy = Path(tmp.name)
+        shutil.copy(input_pdb, input_pdb_copy)
+
+        # Setting up a full workflow set of parameters
+        workflow_params = {
+            "topoaa": {
+                "molecules": [input_pdb_copy],
+                "ligand_param_fname": ems_dict["ligand_param_fname"],
+                "ligand_top_fname": ems_dict["ligand_top_fname"],
+                },
+            "emscoring": ems_dict,
+        }
+
+        print("> starting calculations...")
+
+        # run workflow
+        with working_directory(run_dir):
+            workflow = WorkflowManager(
+                workflow_params=workflow_params,
+                start=0,
+                run_dir=run_dir,
+            )
+            workflow.run()
+
+    # Build expected pdb filepath
+    minimized_mol = Path(run_dir, "1_emscoring", "emscoring_1.pdb")
+    haddock_score_component_dic = HaddockModel(minimized_mol).energies
+
+    vdw = haddock_score_component_dic["vdw"]
+    elec = haddock_score_component_dic["elec"]
+    desolv = haddock_score_component_dic["desolv"]
+    air = haddock_score_component_dic["air"]
+    bsa = haddock_score_component_dic["bsa"]
+
+    # Compute the haddock score
+    # emscoring is equivalent to itw
+    haddock_score_itw = (
+        ems_dict["w_vdw"] * vdw
+        + ems_dict["w_elec"] * elec
+        + ems_dict["w_desolv"] * desolv
+        + ems_dict["w_air"] * air
+        + ems_dict["w_bsa"] * bsa
+        )
+
+    print(
+        "> HADDOCK-score ="
+        f" ({ems_dict['w_vdw']} * vdw)"
+        f" + ({ems_dict['w_elec']} * elec)"
+        f" + ({ems_dict['w_desolv']} * desolv)"
+        f" + ({ems_dict['w_air']} * air)"
+        f" + ({ems_dict['w_bsa']} * bsa)"
+        )
+    print(f"> HADDOCK-score (emscoring) = {haddock_score_itw:.4f}")
+
+    if full:
+        print(f"> vdw={vdw},elec={elec},desolv={desolv},air={air},bsa={bsa}")
+
+    if outputpdb:
+        outputpdb_name = Path(f"{input_pdb.stem}_hs.pdb")
+        print(f"> writing {outputpdb_name}")
+        shutil.copy(
+            Path(run_dir, "1_emscoring", "emscoring_1.pdb"),
+            outputpdb_name,
+            )
+
+    if outputpsf:
+        outputpsf_name = Path(f"{input_pdb.stem}_hs.psf")
+        print(f"> writing {outputpsf_name}")
+        shutil.copy(
+            Path(run_dir, "0_topoaa", f"{input_pdb_copy.stem}_haddock.psf"),
+            outputpsf_name,
+            )
+
+    if not keep_all:
+        shutil.rmtree(run_dir)
+    else:
+        print(
+            'The folder where the calculations were performed was kept.'
+            f' See folder: {run_dir}'
+            )
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_traceback.py

@@ -0,0 +1,370 @@
+"""
+Traces back PDB files from a HADDOCK run directory.
+
+Given an input run directory, haddock3-traceback traces back each model to the
+initial input molecules used, providing the rank of each intermediate model.
+
+USAGE::
+
+    haddock3-traceback -r <run_dir>
+
+"""
+import argparse
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+from haddock import log
+from haddock.core.typing import Any, FilePath
+from haddock.libs import libcli
+from haddock.libs.libontology import ModuleIO, PDBFile
+from haddock.libs.libplots import make_traceback_plot
+from haddock.modules import get_module_steps_folders
+
+
+TRACK_FOLDER = "traceback"  # name of the traceback folder
+
+
+def get_steps_without_pdbs(run_dir, all_steps):
+    """
+    Get the modules that do not produce PDB files.
+
+    Parameters
+    ----------
+    run_dir : str or pathlib.Path
+        Path to the run directory.
+    
+    all_steps : list
+        List of all the steps in the run directory.
+    
+    Returns
+    -------
+    steps_without_pdbs : list
+        List of steps that did not produce PDB files.
+    """
+    steps_without_pdbs = []
+    for step in all_steps:
+        if step.endswith("topoaa"):
+            steps_without_pdbs.append(step)
+        else:
+            step_dir = Path(run_dir, step)
+            if step_dir.is_dir():
+                pdbs = list(step_dir.glob("*.pdb*"))
+                if len(pdbs) == 0:
+                    steps_without_pdbs.append(step)
+    return steps_without_pdbs
+
+
+def get_ori_names(n: int, pdbfile: PDBFile, max_topo_len: int) -> tuple[list, int]:
+    """
+    Get the original name(s) of the PDB file.
+
+    Parameters
+    ----------
+    n : int
+        Step number.
+    pdbfile : PDBFile
+        PDBFile object.
+    max_topo_len : int
+        Maximum length of the topologies found so far.
+
+    Returns
+    -------
+    ori_names : list
+        List of original names.
+    max_topo_len : int
+        Maximum length of the topologies found so far.
+    """
+    if n != 0:  # not the first step, ori_name should be defined
+        ori_names = [pdbfile.ori_name]
+    else:  # first step, we get topology files instead of ori_name
+        # topology can either be a list of topologies or a single
+        # topology
+        if isinstance(pdbfile.topology, list):
+            ori_names = [el.file_name for el in pdbfile.topology]
+            if len(pdbfile.topology) > max_topo_len:
+                max_topo_len = len(pdbfile.topology)
+        else:
+            ori_names = [pdbfile.topology.file_name]  # type: ignore
+            max_topo_len = 1
+    return ori_names, max_topo_len
+
+
+def traceback_dataframe(
+    data_dict: dict, rank_dict: dict, sel_step: list, max_topo_len: int
+) -> pd.DataFrame:
+    """
+    Create traceback dataframe by combining together ranks and data.
+
+    Parameters
+    ----------
+    data_dict : dict
+        Dictionary containing the data to be traced back.
+    rank_dict : dict
+        Dictionary containing the ranks of the data to be traced back.
+    sel_step : list
+        List of selected steps.
+    max_topo_len : int
+        Maximum length of the topologies.
+
+    Returns
+    -------
+    df_ord : pandas.DataFrame
+        Dataframe containing the traceback data.
+    """
+    # get last step of the workflow
+    last_step = sel_step[-1]
+    # data dict to dataframe
+    df_data = pd.DataFrame.from_dict(data_dict, orient="index")
+    df_data.reset_index(inplace=True)
+    # assign columns
+    data_cols = [el for el in reversed(sel_step)]
+    data_cols.extend([f"00_topo{i+1}" for i in range(max_topo_len)])
+    df_data.columns = data_cols
+
+    # same for the rank_dict
+    df_ranks = pd.DataFrame.from_dict(rank_dict, orient="index")
+    df_ranks.reset_index(inplace=True)
+    ranks_col = [last_step]  # the key to merge the dataframes
+    ranks_col.extend([f"{el}_rank" for el in reversed(sel_step)])
+    df_ranks.columns = ranks_col
+
+    # merging the data and ranks dataframes
+    df_merged = pd.merge(df_data, df_ranks, on=last_step)
+    ordered_cols = sorted(df_merged.columns)
+    df_ord = df_merged[ordered_cols]
+    # last thing: substituting unk records with - in the last step
+    unk_records = df_ord[f"{last_step}"].str.startswith("unk")
+    df_ord.loc[unk_records, last_step] = "-"
+    return df_ord
+
+
+def order_traceback_df(df_output, sel_step):
+    """
+    Order the traceback dataframe. Each step is ordered by rank.
+
+    Parameters
+    ----------
+    df_output : pandas.DataFrame
+        Dataframe containing the traceback data.
+    
+    sel_step : list
+        List of selected steps.
+    
+    Returns
+    -------
+    df_output : pandas.DataFrame
+        Dataframe containing the ordered traceback data.
+    """
+    # loop over sel_step in reverse order
+    sorted_list = []
+    indexes = []
+    for n in range(len(sel_step) - 1, -1, -1):
+        rank_col = sel_step[n] + "_rank"
+        # take only models with a rank
+        df_last = df_output[df_output[rank_col] != "-"]
+        # remove from df_last the indexes that are already in the dataframe
+        df_last = df_last[~df_last.index.isin(indexes)]
+        # sorting the dataframe by rank
+        sorted_df_last = df_last.sort_values(by=rank_col)
+        sorted_list.append(sorted_df_last)
+        # concat the current indexes with the previous ones
+        indexes = sorted_df_last.index.tolist() + indexes
+    df_output = pd.concat(sorted_list)
+    return df_output
+
+
+def subset_traceback(traceback_df: pd.DataFrame, cons_filename: Path) -> pd.DataFrame:
+    """
+    Generate a subset the traceback dataframe with the top 40 models.
+
+    Parameters
+    ----------
+    traceback_df : pandas.DataFrame
+        Dataframe containing the traceback data.
+    
+    cons_filename : pathlib.Path
+        name of the consensus file.
+    
+    Returns
+    -------
+    rank_data_subset : pandas.DataFrame
+        Dataframe containing the subset of the traceback data.
+    """
+    red_traceback_df = traceback_df.head(40)
+    rank_data = red_traceback_df.filter(regex='rank$')
+    # get the last column: this will define the name of the models
+    last_column = red_traceback_df.columns[-2]
+    last_column_data = red_traceback_df[last_column]
+    # concat the ranks with the model name
+    rank_data = pd.concat([last_column_data, rank_data], axis=1)
+    # the rank of the last column must be defined
+    last_column_rank = last_column + "_rank"
+    # copy avoids SettingWithCopyWarning
+    rank_data_subset = rank_data[rank_data[last_column_rank] != '-'].copy()
+    rank_columns = rank_data_subset.columns[1:].tolist()
+    rank_data_subset[rank_columns] = rank_data_subset[rank_columns].apply(pd.to_numeric, errors='coerce')
+    rank_data_subset = rank_data_subset.sort_values(by=last_column_rank, ascending=True)
+    
+    # rename the columns
+    rank_data_subset.columns = ["Model"] + rank_columns
+    # sum the ranks
+    rank_data_subset["Sum-of-Ranks"] = rank_data_subset[rank_columns].sum(axis=1)
+    rank_data_subset.to_csv(cons_filename, index=False, sep="\t")
+    return rank_data_subset
+
+
+# Command line interface parser
+ap = argparse.ArgumentParser(
+    prog="haddock3-traceback",
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+libcli.add_rundir_arg(ap)
+
+
+def load_args(ap):
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap, main):
+    """Command-line interface entry point."""
+    cmd = vars(load_args(ap))
+    main(**cmd)
+
+
+def maincli():
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(run_dir: FilePath, offline: bool = False) -> None:
+    """
+    Traceback CLI.
+
+    Parameters
+    ----------
+    run_dir : str or Path
+        Path to the original run directory.
+    """
+    log.level = 20
+    log.info(f"Running haddock3-traceback on {run_dir}")
+
+    # Reading steps
+    log.info("Reading input run directory")
+    # get the module folders from the run_dir input
+    all_steps = get_module_steps_folders(Path(run_dir))
+    log.info(f"All_steps: {', '.join(all_steps)}")
+    ana_modules = get_steps_without_pdbs(run_dir, all_steps)
+    log.info(f"Modules not to be analysed: {', '.join(ana_modules)}")
+    sel_step = [st for st in all_steps if st not in ana_modules]
+    # check if there are steps to traceback
+    if len(sel_step) == 0:
+        log.info("No steps to trace back. Exiting.")
+        return
+    else:
+        log.info(f"Steps to trace back: {', '.join(sel_step)}")
+
+    # creating traceback folder
+    outdir = Path(run_dir, TRACK_FOLDER)
+    try:
+        outdir.mkdir(exist_ok=False)
+        log.info(f"Created directory: {str(outdir.resolve())}")
+    except FileExistsError:
+        log.warning(f"Directory {str(outdir.resolve())} already exists.")
+
+    data_dict: dict[Any, Any] = {}
+    rank_dict: dict[Any, Any] = {}
+    unk_idx, max_topo_len = 0, 0
+    # this cycle goes through the steps in reverse order
+    for n in range(len(sel_step) - 1, -1, -1):
+        log.info(f"Tracing back step {sel_step[n]}")
+        # correcting names in the dictionary. The ori_name must be complemented
+        # with the step folder name
+        for key in data_dict.keys():
+            if data_dict[key][-1] != "-":
+                data_dict[key][-1] = f"../{sel_step[n]}/{data_dict[key][-1]}"
+
+        delta = len(sel_step) - n - 1  # how many steps have we gone back?
+        # loading the .json file
+        json_path = Path(run_dir, sel_step[n], "io.json")
+        io = ModuleIO()
+        io.load(json_path)
+        # list all the values in the data_dict
+        ls_values = [x for val in data_dict.values() for x in val]
+        # getting and sorting the ranks for the current step folder
+        ranks = [pdbfile.score for pdbfile in io.output]
+        ranks_argsort = np.argsort(ranks)
+
+        # iterating through the pdbfiles to fill data_dict and rank_dict
+        for i, pdbfile in enumerate(io.output):
+            rank = np.where(ranks_argsort == i)[0][0] + 1
+            # getting the original names
+            ori_names, max_topo_len = get_ori_names(n, pdbfile, max_topo_len)
+            if n != len(sel_step) - 1:
+                if str(pdbfile.rel_path) not in ls_values:
+                    # this is the first step in which the pdbfile appears.
+                    # This means that it was discarded for the subsequent steps
+                    # We need to add the pdbfile to the data_dict
+                    keys = [f"unk{unk_idx}"]
+                    data_dict[keys[0]] = ["-" for el in range(delta - 1)]
+                    data_dict[keys[0]].append(str(pdbfile.rel_path))
+                    rank_dict[keys[0]] = ["-" for el in range(delta)]
+                    unk_idx += 1
+                else:
+                    # we've already seen this pdb before.
+                    idxs = [i for i, el in enumerate(ls_values) if el==str(pdbfile.rel_path)]
+                    keys = [list(data_dict.keys())[idx // delta] for idx in idxs]
+
+                # assignment
+                for el in ori_names:
+                    for key in keys:
+                        data_dict[key].append(el)
+                for key in keys:
+                    rank_dict[key].append(rank)
+            else:  # last step of the workflow
+                data_dict[str(pdbfile.rel_path)] = [on for on in ori_names]
+                rank_dict[str(pdbfile.rel_path)] = [rank]
+
+        # print(f"rank_dict {rank_dict}")
+        # print(f"data_dict {data_dict}, maxtopo {max_topo_len}")
+
+    # stripping away relative paths
+    final_data_dict = {}
+    for key in data_dict.keys():
+        new_key = key.split("/")[-1]
+        final_data_dict[new_key] = [el.split("/")[-1] for el in data_dict[key]]
+    final_rank_dict = {}
+    for key in rank_dict.keys():
+        new_key = key.split("/")[-1]
+        final_rank_dict[new_key] = rank_dict[key]
+    # dumping the data into a dataframe
+    df_output = traceback_dataframe(
+        final_data_dict, final_rank_dict, sel_step, max_topo_len
+    )
+
+    # ordering the dataframe
+    df_output = order_traceback_df(df_output, sel_step)
+    # dumping the dataframe
+    track_filename = Path(run_dir, TRACK_FOLDER, "traceback.tsv")
+    log.info(
+        f"Output dataframe {track_filename} " f"created with shape {df_output.shape}"
+    )
+    df_output.to_csv(track_filename, sep="\t", index=False)
+
+    # taking (and writing) a subset of the dataframe
+    consensus_filename = Path(run_dir, TRACK_FOLDER, "consensus.tsv")
+    rank_data_subset = subset_traceback(df_output, consensus_filename)
+
+    # plotting the traceback dataframe
+    plot_filename = Path(run_dir, TRACK_FOLDER, "traceback.html")
+    make_traceback_plot(rank_data_subset, plot_filename, offline=offline)
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())

.venv_haddock/lib/python3.12/site-packages/haddock/clis/cli_unpack.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+Unpack the output of an HADDOCK3 run directory.
+
+The unpack process performs file unpacking and file decompressing
+operations.  File with extension `seed` and `con` are unpacked from
+their `.tgz` files.  While files with `.pdb.gz` and `.psf.gz` extension
+are uncompressed.  If `--all` is given, unpack also `.inp.gz` and
+`.out.gz` files.
+
+This CLI performs the opposite operations as the ``haddock3-clean``
+command-line.
+
+The <run_directory> can either be a whole HADDOCK3 run folder or a
+specific folder of the workflow step. <ncores> defined the number of
+threads to use.
+
+Usage::
+
+    haddock3-unpack -h
+    haddock3-unpack -r <run_directory>
+    haddock3-unpack run1
+    haddock3-unpack run1/1_rigidbody
+    haddock3-unpack run1 -n  # uses all cores
+    haddock3-unpack run1 -n 2  # uses 2 cores
+    haddock3-unpack run1 -n 2 -a
+    haddock3-unpack run1 -n 2 --all
+"""
+import argparse
+import sys
+
+from haddock.core.typing import (
+    ArgumentParser,
+    Callable,
+    FilePath,
+    Namespace,
+    Optional,
+)
+from haddock.libs import libcli
+
+
+# Command line interface parser
+ap = argparse.ArgumentParser(
+    description=__doc__,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+)
+
+libcli.add_rundir_arg(ap)
+
+ap.add_argument(
+    "--all",
+    "-a",
+    dest="dec_all",
+    help="Unpack all files (includes `.inp` and `.out`).",
+    action="store_true",
+)
+
+libcli.add_ncores_arg(ap)
+libcli.add_version_arg(ap)
+
+
+def _ap() -> ArgumentParser:
+    return ap
+
+
+def load_args(ap: ArgumentParser) -> Namespace:
+    """Load argument parser args."""
+    return ap.parse_args()
+
+
+def cli(ap: ArgumentParser, main: Callable[..., None]) -> None:
+    """Command-line interface entry point."""
+    cmd = load_args(ap)
+    main(**vars(cmd))
+
+
+def maincli() -> None:
+    """Execute main client."""
+    cli(ap, main)
+
+
+def main(run_dir: FilePath, ncores: Optional[int] = 1, dec_all: bool = False) -> None:
+    """
+    Unpack a HADDOCK3 run directory step folders.
+
+    Usually, this concerns uncompressing and unpacking files.
+
+    It performs the oposity function as
+    :py:func:`haddock.clis.cli_clean.main`.
+
+    Parameters
+    ----------
+    run_dir : str or :external:py:class:`pathlib.Path`.
+        The path to the run directory or to a folder of a specific step
+        of the workflow.
+
+    ncores : int, or None
+        The number of cores to use. If ``None``, use all possible threads.
+        Defaults to 1.
+
+    See Also
+    --------
+    `haddock.gear.clean_steps`
+    """
+    # anti-pattern to speed up CLI initiation
+    from pathlib import Path
+
+    from haddock import log
+    from haddock.gear.clean_steps import unpack_compressed_and_archived_files
+    from haddock.libs.libtimer import log_time
+    from haddock.libs.libutil import parse_ncores
+    from haddock.modules import get_module_steps_folders, is_step_folder
+
+    log.info(f"Unpacking {str(run_dir)!r} folder")
+    ncores = parse_ncores(ncores)
+
+    if is_step_folder(run_dir):
+        with log_time("unpacking took"):
+            unpack_compressed_and_archived_files(
+                [run_dir],
+                ncores,
+                dec_all=dec_all,
+            )
+
+    else:
+        step_folders = [Path(run_dir, p) for p in get_module_steps_folders(run_dir)]
+        with log_time("unpacking took"):
+            unpack_compressed_and_archived_files(
+                step_folders,
+                ncores,
+                dec_all=dec_all,
+            )
+
+    return
+
+
+if __name__ == "__main__":
+    sys.exit(maincli())  # type: ignore

.venv_haddock/lib/python3.12/site-packages/haddock/clis/wrapper_haddock_restraints.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+from importlib.resources import files
+
+
+def main():
+
+    binary = Path(files("haddock").joinpath("bin/haddock-restraints"))  # type: ignore
+    sys.argv[0] = str(binary)  # Replace argv[0] with actual binary path
+
+    # Execute the binary
+    import subprocess
+
+    sys.exit(subprocess.run([str(binary)] + sys.argv[1:]).returncode)
+
+
+if __name__ == "__main__":
+    main()

.venv_haddock/lib/python3.12/site-packages/haddock/core/__init__.py

@@ -0,0 +1,3 @@
+"""
+Core haddock3 functionalities.
+"""

.venv_haddock/lib/python3.12/site-packages/haddock/core/cns_paths.py

@@ -0,0 +1,99 @@
+"""
+Path to CNS-related files.
+
+Most paths are defined by dictionaries that gather several related
+paths. Here, instead of defining the dictionaries with static paths, we
+have functions that create those dict-containing paths dynamically. The
+default values are defined by:
+
+- axis
+- tensors
+- translation_vectors
+- water_box
+
+But you can re-use the functions to create new dictionaries with updated
+paths. This is useful for those cases when the `cns/` folder is moved
+to a different folder.
+"""
+from pathlib import Path
+
+from haddock import toppar_path
+from haddock.core.typing import FilePath
+
+
+# exact file names as present in the cns/ scripts folder
+LINK_FILE = "protein-allhdg5-4-noter.link"
+SCATTER_LIB = "scatter.lib"
+INITIAL_POSITIONS_DIR = "initial_positions"
+
+PROTEIN_LINK_FILES = {
+    "NH3+,COO-": "protein-allhdg5-4.link",
+    "NH,COO-": "protein-allhdg5-4-noNter.link",
+    "NH3+,CO": "protein-allhdg5-4-noCter.link",
+    "NH,CO": LINK_FILE,
+}
+NUCL_LINK_FILES = {
+    "5'Phosphate": "dna-rna-pho-1.3.link",
+    "5'OH": "dna-rna-1.3.link",
+}
+
+# default prepared paths
+link_file = Path(toppar_path, LINK_FILE)
+scatter_lib = Path(toppar_path, SCATTER_LIB)
+
+
+def get_translation_vectors(path: FilePath) -> dict[str, Path]:
+    """
+    Generate paths for translation vectors.
+
+    Parameters
+    ----------
+    path : pathlib.Path
+        If absolute, paths will be absolute, if relative paths will be
+        relative. Adds the INITIAL_POSITIONS_DIR path before the file
+        name.
+    """
+    translation_vectors: dict[str, Path] = {}
+    for i in range(51):
+        _s = f'trans_vector_{i}'
+        _p = Path(path, INITIAL_POSITIONS_DIR, _s)
+        translation_vectors[_s] = _p
+
+    return translation_vectors
+
+
+def get_tensors(path: FilePath) -> dict[str, Path]:
+    """Generate paths for tensors."""
+    tensors = {
+        "tensor_psf": Path(path, "tensor.psf"),
+        "tensor_pdb": Path(path, "tensor.pdb"),
+        "tensor_para_psf": Path(path, "tensor_para.psf"),
+        "tensor_para_pdb": Path(path, "tensor_para.pdb"),
+        "tensor_dani_psf": Path(path, "tensor_dani.psf"),
+        "tensor_dani_pdb": Path(path, "tensor_dani.pdb"),
+        }
+    return tensors
+
+
+def get_axis(path: FilePath) -> dict[str, Path]:
+    """Generate paths for axis."""
+    axis = {
+        "top_axis": Path(path, "top_axis.pro"),
+        "par_axis": Path(path, "par_axis.pro"),
+        "top_axis_dani": Path(path, "top_axis_dani.pro"),
+        }
+    return axis
+
+
+def get_water_box(path: FilePath) -> dict[str, Path]:
+    """Generate paths for water box."""
+    water_box = {
+        "boxtyp20": Path(path, "boxtyp20.pdb"),
+        }
+    return water_box
+
+
+axis = get_axis(toppar_path)
+tensors = get_tensors(toppar_path)
+translation_vectors = get_translation_vectors(toppar_path)
+water_box = get_water_box(toppar_path)

.venv_haddock/lib/python3.12/site-packages/haddock/core/defaults.py

@@ -0,0 +1,47 @@
+"""All default parameters used by the framework."""
+
+import string
+from importlib.resources import files
+from pathlib import Path
+
+import yaml
+
+from haddock import core_path
+from haddock.libs.libutil import get_cns_executable, get_prodrg_exec
+
+cns_exec, cns_exec_linux = get_cns_executable()
+prodrg_exec, prodrg_param = get_prodrg_exec()
+
+CONTACT_FCC_EXEC = Path(files("haddock").joinpath("bin/contact_fcc"))  # type: ignore
+FAST_RMSDMATRIX_EXEC = Path(files("haddock").joinpath("bin/fast-rmsdmatrix"))  # type: ignore
+
+MODULE_PATH_NAME = "step_"
+"""
+Module input and generated data will be stored in folder starting by
+this prefix"""
+
+MODULE_IO_FILE = "io.json"
+"""Default name for exchange module information file"""
+
+MAX_NUM_MODULES = 10000
+"""Temptative number of max allowed number of modules to execute"""
+
+valid_run_dir_chars = string.ascii_letters + string.digits + "._-/\\"
+
+RUNDIR = "run_dir"
+"""Default run directory name."""
+
+INTERACTIVE_RE_SUFFIX = "interactive"
+"""Suffix added to interactive haddock3-re runs."""
+
+MODULE_DEFAULT_YAML = "defaults.yaml"
+"""Default name of the yaml default parameters file."""
+
+CNS_MODULES = ["rigidbody", "flexref", "emscoring", "mdscoring", "mdref", "emref"]
+"""List of CNS modules available in HADDOCK3."""
+
+
+with open(Path(core_path, "mandatory.yaml"), "r") as fin:
+    _ycfg = yaml.safe_load(fin)
+max_molecules_allowed = _ycfg["molecules"]["maxitems"]
+del _ycfg

.venv_haddock/lib/python3.12/site-packages/haddock/core/exceptions.py

@@ -0,0 +1,79 @@
+"""HADDOCK library custom errors."""
+
+from os import linesep
+
+from haddock.core.typing import FilePath
+
+class HaddockError(Exception):
+    """Error in HADDOCK3."""
+
+    pass
+
+
+class ConfigurationError(HaddockError):
+    """Error in the configuration file."""
+
+    pass
+
+
+class ModuleError(HaddockError):
+    """Error in a HADDOCK3 module."""
+
+    pass
+
+
+class StepError(HaddockError):
+    """Error in a HADDOCK3 workflow step."""
+
+    pass
+
+
+class JobRunningError(HaddockError):
+    """General job running error."""
+
+    pass
+
+
+class CNSRunningError(HaddockError):
+    """CNS run error."""
+
+    pass
+
+class KnownCNSError(CNSRunningError):
+    """Detected CNS output error."""
+
+    def __init__(self, cns_message: str, hint: str, filepath: FilePath):
+        self.cns_error = cns_message
+        self.hint = hint
+        self.filepath = filepath
+    
+    def __str__(self) -> str:
+        """Generate custom string representation of this exception."""
+        full_msg = (
+            f"A CNS error occured: `{self.cns_error}`.{linesep}"
+            f"Here is a hint on how to solve it:{linesep}{self.hint}"
+            )
+        return full_msg
+
+
+class HaddockModuleError(HaddockError):
+    """General error in a HADDOCK3 module."""
+
+    pass
+
+
+class ThirdPartyIntallationError(HaddockModuleError):
+    """General error when a third party module is not properly installed."""
+
+    pass
+
+class SetupError(HaddockError):
+    """Set up error."""
+
+    pass
+
+
+class HaddockTermination(HaddockError):
+    """Terminates HADDOCK."""
+
+    pass

.venv_haddock/lib/python3.12/site-packages/haddock/core/mandatory.yaml

@@ -0,0 +1,18 @@
+run_dir:
+  type: dir
+  title: Run directory
+  short: Folder to store the HADDOCK3 run
+  long: The new folder that will be created to save the HADDOCK3 run
+  explevel: easy
+molecules:
+  type: list
+  accept:
+    - ".pdb"
+  minitems: 1
+  maxitems: 20
+  title: Input Molecules
+  short: The input molecules that will be used for docking.
+  long:
+    Molecules must be provided in PDB format. These PDB files can be
+    single molecules or ensembles using the MODEL/ENDMDL statements.
+  explevel: easy

.venv_haddock/lib/python3.12/site-packages/haddock/core/optional.yaml

@@ -0,0 +1,32 @@
+preprocess:
+  default: false
+  type: boolean
+  title: Tries to correct input PDBs
+  short: If true, evaluates and tries to correct the input PDB before the
+    workflow.
+  long: HADDOCK3 checks and processes the input PDB files to ensure they
+    all comply with HADDOCK3's requirements. These checks concerns, for example,
+    residue numbering, compatibility of chain IDs, and many others. You can see
+    all checks performs in the live issue
+    https://github.com/haddocking/haddock3/issues/143. If set to false, no
+    checks are performed and HADDOCK3 directly uses the original input PDBs.
+  explevel: easy
+postprocess:
+  default: true
+  type: boolean
+  title: Executes haddock3-analyse on the CAPRI folders at the end of the run
+  short: If true, executes haddock3-analyse on the CAPRI folders at the end of 
+    the workflow
+  long: haddock3-analyse is a cli (see https://github.com/haddocking/haddock3/blob/main/src/haddock/clis/cli_analyse.py)
+    used to plot the results of a HADDOCK3 workflow. If this option, this command
+    is automatically executed at the end of the workflow (on the caprieval folders).
+  explevel: easy
+gen_archive:
+  default: false
+  type: boolean
+  title: Generates an archive of the run and of the analysis.
+  short: If true, executes haddock3-analyse in self_contained mode and generates
+    archives of the run_directory and of the analysis in two separated tgz files.
+  long: If true, executes haddock3-analyse in self_contained mode and generates
+    archives of the run_directory and of the analysis in two separated tgz files.
+  explevel: easy

.venv_haddock/lib/python3.12/site-packages/haddock/core/supported_molecules.py

@@ -0,0 +1,497 @@
+"""
+HADDOCK 3 supported residues.
+
+The HADDOCK3 supported residues are defined by the different ``.top``
+files in the ``cns/toppar`` source folder. This module will automatically
+retrieve any new residue added to the ``.top`` defined in the folder and
+add it to the variables here.
+
+If a new ``.top`` file is added in the folder, that must be added here
+inside the :py:func:`read_supported_residues` function, because file retrieve is
+not done automatically on purpose.
+
+``.top`` files considered here:
+
+* ``carbohydrate.top``
+* ``dna-rna-CG-MARTINI-2-1p.top``
+* ``dna-rna-allatom-hj-opls-1.3.top``
+* ``fragment_probes.top``
+* ``hemes-allhdg.top``
+* ``ion.top``
+* ``protein-CG-Martini-2-2.top``
+* ``protein-CG-Martini.top``
+* ``protein-allhdg5-4.top``
+* ``solvent-allhdg5-4.top``
+* ``shape.top``
+* ``cofactors.top``
+
+DNA-related files are all concatenated into a single DNA-supported
+residues datastructure. The same occurs for protein residues (natural or
+modified).
+
+You can import from this module the different sets containing the
+supported residue names:
+
+* :py:data:`supported_aminoacids_resnames`
+* :py:data:`supported_carbo_resnames`
+* :py:data:`supported_fragments_resnames`
+* :py:data:`supported_hemes_resnames`
+* :py:data:`supported_single_ions_resnames`
+* :py:data:`supported_single_ions_elements`
+* :py:data:`supported_single_ions_atoms`
+* :py:data:`supported_multiatom_ions_resnames`
+* :py:data:`supported_nucleic_resnames`
+* :py:data:`supported_solvents_resnames`
+* :py:data:`supported_shape`
+* :py:data:`supported_cofactors_resnames`
+
+* :py:data:`supported_ATOM` (contains residues and nucleic acids)
+* :py:data:`supported_HETATM` (everything not contained in ATOM)
+"""
+import itertools as it
+import re
+import string
+from copy import copy
+from pathlib import Path
+
+from haddock import toppar_path
+from haddock.core.typing import FilePath, Iterable
+
+
+class CNSTopologyResidue:
+    """CNS topology residue."""
+
+    def __init__(self, resname: str, charge: float,
+                 atoms: Iterable[str]) -> None:
+        """
+        CNS topology residue.
+
+        This is not an actual topology. It is a namespace storing the
+        basic parameters defined in CNS residue topologies.
+
+        So far, this is used by the
+        :py:module:`haddock.gear.preprocessing` step; but this class can
+        be extended with additional parameters if needed.
+
+        Parameters
+        ----------
+        resname : str
+            The name of the residue.
+
+        charge : float
+            The charge of the residue. The charge will be round to two
+            decimal places.
+
+        atoms : list-like
+            The list of atom names. Will be converted to a tuple.
+        """
+        self._resname = resname
+        self._charge = round(charge, 2)
+        self._atoms = tuple(atoms)
+        return
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return (
+            f"{self.__class__.__name__}({self.resname!r}, "
+            f"{self.charge!r}, {self.atoms!r})"
+            )
+
+    @property
+    def resname(self) -> str:
+        """Residue name."""
+        return self._resname
+
+    @property
+    def charge(self) -> float:
+        """Residue total charge."""
+        return self._charge
+
+    @property
+    def atoms(self) -> tuple[str, ...]:
+        """Tuple of residue atoms."""
+        return self._atoms
+
+    @property
+    def elements(self) -> tuple[str, ...]:
+        """
+        List of elements for all atoms composing the molecule.
+
+        This list is ordered the same as ``atoms``.
+
+        By default ``elements`` is not defined and must be injected manually.
+
+        See Also
+        --------
+        * :py:func:`get_ion_element_from_atoms`
+        """
+        try:
+            return self._elements
+        except AttributeError as err:
+            emsg = "`elements` is not defined."
+            raise AttributeError(emsg) from err
+
+    @elements.setter
+    def elements(self, elements: tuple[str, ...]) -> None:
+        self._elements = elements
+
+
+def get_ion_element_from_atoms(atoms: Iterable[str]) -> tuple[str, ...]:
+    """
+    Generate the element name from the atom name for single atom ions.
+
+    Examples
+    --------
+    >>> get_ion_element_from_atoms(["ZN+2", "CU+2", "NI"])
+    ("ZN", "CU", "NI")
+
+    Parameters
+    ----------
+    atom : list
+        A list of atom names.
+    """
+    ele = (a.rstrip(string.digits + "+-") for a in atoms)
+    return tuple(ele)
+
+
+def read_residues_from_top_file(topfile: FilePath) -> list[CNSTopologyResidue]:
+    """
+    Read the residues defined in CNS topology file.
+
+    This is a general implementation to read the basic information from
+    the CNS topology files. This basic information is the information
+    needed to help the the :py:mod:`haddock.gear.preprocessing` step
+    in identifying the supported residues and correctly format their PDB
+    lines.
+
+    Parameters
+    ----------
+    topfile : str or :external:py:class:`pathlib.Path`
+        Path to the topology file.
+
+    Returns
+    -------
+    list
+        List of :class:`CNSTopologyResidue` objects.
+        Each object has information on the residue name, the atoms,
+        and the total charge of the residue.
+
+    See Also
+    --------
+    * :py:func:`haddock.gear.preprocessing.read_additional_residues`
+    """
+    # just to avoid identention with with
+    fin = open(topfile, 'r')
+    lines = fin.readlines()
+    fin.close()
+    return _read_residues_from_top_file(lines)
+
+
+def _read_residues_from_top_file(
+        lines: Iterable[str]) -> list[CNSTopologyResidue]:
+    # regular expression to parse information from atom lines
+    atom_regex = (
+        r"^ATOM +([A-Z0-9\'\+\-]{1,4}) +.* +(?:charge|CHARGE|CHARge) *= *"
+        r"([\-|+]?\d+.?\d*).*(?:END|end).*$"
+        )
+
+    # helper variables for the for-loop
+    atoms: list[str] = []
+    charges: list[str] = []
+    residues: list[CNSTopologyResidue] = []
+    in_residue: bool = False
+
+    # all lines are striped before looping
+    for line in map(str.strip, lines):  # it is important to strip spaces
+        if line.startswith(('RESI', 'residue')):
+            in_residue = True  # defines we start a new residue
+
+            # extracts the resname from the residue line
+            resname = line.split()[1]
+
+            # ensures there is no bug when changing residues
+            # before starting a new residue `atoms` and `charges` should be
+            # empty
+            if atoms or charges:
+                emsg = \
+                    "Starting a new residue without emptying the previous one."
+                raise ValueError(emsg)
+
+        elif line.startswith('ATOM'):
+            aname, acharge = re.findall(atom_regex, line)[0]
+            atoms.append(aname)
+            charges.append(acharge)
+
+        elif line.startswith(("end", "END")) and in_residue:
+
+            # the total charge of the residue
+            total_charge = sum(map(float, charges))
+            # need to be a copy to avoid unexpected referencing from the list
+            _atoms = copy(atoms)
+
+            resi = CNSTopologyResidue(resname, total_charge, _atoms)
+            residues.append(resi)
+
+            # clear help variables
+            charges.clear()
+            atoms.clear()
+            in_residue = False
+
+    return residues
+
+
+# what we will need to inspect if the residues are allowed or not are
+# the residue names. So it is nice to have a function that retrieve them
+# from the respective named tuples.
+def get_resnames(
+        group: Iterable[CNSTopologyResidue]) -> dict[str, CNSTopologyResidue]:
+    """
+    Make a set of residue names.
+
+    Elements of the group must have a `resname` attribute.
+
+    Parameters
+    ----------
+    group : list of :py:class:`CNSTopologyResidue`
+
+    Returns
+    -------
+    dict
+        Dict of residue name and residue pairs.
+    """
+    return {i.resname: i for i in group}
+
+
+# this function is necessary because of the `self_contained` option
+# where the topology files are not defined in the haddock3 code but in
+# the run folder
+def read_supported_residues(
+        source_path: FilePath) -> tuple[dict[str, CNSTopologyResidue], ...]:
+    """
+    Read supported residues from a folder containing ``.top`` files.
+
+    The function expects the ``source_path`` to have the required files.
+
+    Expected files are:
+
+    * ``carbohydrate.top``
+    * ``dna-rna-CG-MARTINI-2-1p.top``
+    * ``dna-rna-allatom-hj-opls-1.3.top``
+    * ``fragment_probes.top``
+    * ``hemes-allhdg.top``
+    * ``ion.top``
+    * ``protein-CG-Martini-2-2.top``
+    * ``protein-CG-Martini.top``
+    * ``protein-allhdg5-4.top``
+    * ``solvent-allhdg5-4.top``
+    * ``shape.top``
+    * ``cofactors.top``
+
+    You need to edit this function to account for any additional
+    ``.top`` file that is added to the ``source_path`` on top of the
+    above ones. Otherwise, read the residues manually using
+    :py:func:`read_residues_from_top_file` and :py:func:`get_resnames`
+    and add them to the relevant set, or have them as a new set.
+
+    Returns
+    -------
+    tuple
+        A tuple of the residue names supported by HADDOCK3.
+    """
+    # paths to the `.top` files
+    carbo_top = Path(source_path, "carbohydrate.top")
+    dna_rna_all_top = Path(source_path, "dna-rna-allatom-hj-opls-1.3.top")
+    dna_rna_martini_top = Path(source_path, "dna-rna-CG-MARTINI-2-1p.top")
+    fragment_top = Path(source_path, "fragment_probes.top")
+    hemes_top = Path(source_path, "hemes-allhdg.top")
+    ions_top = Path(source_path, "ion.top")
+    protein_5_4_top = Path(source_path, "protein-allhdg5-4.top")
+    protein_martini_2_top = Path(source_path, "protein-CG-Martini-2-2.top")
+    protein_martini_top = Path(source_path, "protein-CG-Martini.top")
+    solvent_top = Path(source_path, "solvent-allhdg5-4.top")
+    shape_top = Path(source_path, "shape.top")
+    cofactors_top = Path(source_path, "cofactors.top")
+
+    # supported Residues (tuple of namedtuples)
+    supported_carbohydrates = read_residues_from_top_file(carbo_top)
+
+    _1 = read_residues_from_top_file(dna_rna_all_top)
+    _2 = read_residues_from_top_file(dna_rna_martini_top)
+    supported_nucleic = set(it.chain(_1, _2))
+
+    supported_fragments = read_residues_from_top_file(fragment_top)
+
+    supported_hemes = read_residues_from_top_file(hemes_top)
+
+    # all ions are defined here
+    supported_ions = read_residues_from_top_file(ions_top)
+
+    # separates both kinds of ions
+    supported_single_ions = \
+        tuple(ion for ion in supported_ions if len(ion.atoms) == 1)
+    supported_multiatom_ions = \
+        tuple(ion for ion in supported_ions if len(ion.atoms) > 1)
+
+    _l0 = len(supported_ions)
+    _l1 = len(supported_single_ions)
+    _l2 = len(supported_multiatom_ions)
+    if _l0 != _l1 + _l2:
+        emsg = (
+            "Ions were not parsed correctly. Some atoms were left out "
+            "when parsing single atom and multiatom ions."
+            )
+        raise ValueError(emsg)
+
+    _1 = read_residues_from_top_file(protein_5_4_top)
+    _2 = read_residues_from_top_file(protein_martini_2_top)
+    _3 = read_residues_from_top_file(protein_martini_top)
+    supported_aminoacids = set(it.chain(_1, _2, _3))
+
+    supported_solvents = read_residues_from_top_file(solvent_top)
+    supported_shape = read_residues_from_top_file(shape_top)
+    supported_cofactors = read_residues_from_top_file(cofactors_top)
+
+    # supported resnames
+    supported_carbo_resnames = get_resnames(supported_carbohydrates)
+    supported_nucleic_resnames = get_resnames(supported_nucleic)
+    supported_fragments_resnames = get_resnames(supported_fragments)
+    supported_hemes_resnames = get_resnames(supported_hemes)
+    supported_single_ions_resnames = get_resnames(supported_single_ions)
+    supported_multiatom_ions_resnames = get_resnames(supported_multiatom_ions)
+    supported_aminoacids_resnames = get_resnames(supported_aminoacids)
+    supported_solvents_resnames = get_resnames(supported_solvents)
+    supported_shape_resnames = get_resnames(supported_shape)
+    supported_cofactors_resnames = get_resnames(supported_cofactors)
+
+    # other attributes
+    for ion in supported_single_ions:
+        ion.elements = get_ion_element_from_atoms(ion.atoms)
+
+    supported_ions_elements = \
+        {ion.elements[0]: ion for ion in supported_single_ions}
+
+    supported_ions_atoms = {ion.atoms[0]: ion for ion in supported_ions}
+
+    return (
+        supported_carbo_resnames,
+        supported_nucleic_resnames,
+        supported_fragments_resnames,
+        supported_hemes_resnames,
+        supported_single_ions_resnames,
+        supported_ions_elements,
+        supported_ions_atoms,
+        supported_multiatom_ions_resnames,
+        supported_aminoacids_resnames,
+        supported_solvents_resnames,
+        supported_shape_resnames,
+        supported_cofactors_resnames,
+        )
+
+
+# reads and assigns the supported molecules variables to this module
+_supported_carbo_resnames, \
+    _supported_nucleic_resnames, \
+    _supported_fragments_resnames, \
+    _supported_hemes_resnames, \
+    _supported_single_ions_resnames, \
+    _supported_single_ions_elements, \
+    _supported_single_ions_atoms, \
+    _supported_multiatom_ions_resnames, \
+    _supported_aminoacids_resnames, \
+    _supported_solvents_resnames, \
+    _supported_shape_resnames, \
+    _supported_cofactors_resnames = read_supported_residues(toppar_path)
+
+# render docstrings
+supported_carbo_resnames = set(_supported_carbo_resnames)
+"""Supported carbohydrate residues names."""
+
+supported_nucleic_resnames = set(_supported_nucleic_resnames)
+"""Supported nucleic acid residue names."""
+
+supported_fragments_resnames = set(_supported_fragments_resnames)
+"""Supported fragments residue names."""
+
+supported_hemes_resnames = set(_supported_hemes_resnames)
+"""Supported Hemes."""
+
+supported_single_ions_resnames_map = _supported_single_ions_resnames
+"""Supported single ion resname mapping."""
+
+supported_single_ions_elements_map = _supported_single_ions_elements
+"""Supported single ions elements mapping."""
+
+supported_single_ions_atoms_map = _supported_single_ions_atoms
+"""Supported single ion atom names mapping."""
+
+supported_single_ions_resnames = set(_supported_single_ions_resnames)
+"""Supported single residue names."""
+
+supported_single_ions_elements = set(_supported_single_ions_elements)
+"""Supported single ions elements."""
+
+supported_single_ions_atoms = set(_supported_single_ions_atoms)
+"""Supported single ion atom names."""
+
+supported_multiatom_ions_resnames = set(_supported_multiatom_ions_resnames)
+"""Supported multiatom ions residue names."""
+
+supported_aminoacids_resnames = set(_supported_aminoacids_resnames)
+"""Supported amino acids residue names."""
+
+supported_solvents_resnames = set(_supported_solvents_resnames)
+"""Supported solvents."""
+
+supported_shape_resnames = set(_supported_shape_resnames)
+"""Supported shape."""
+
+supported_cofactors_resnames = set(_supported_cofactors_resnames)
+"""Supported cofactors."""
+
+#
+# Residues that must be set as ATOM
+supported_ATOM = set(it.chain(
+    supported_nucleic_resnames,
+    supported_aminoacids_resnames,
+    supported_shape_resnames,
+    ))
+"""
+Supported ``ATOM`` residues.
+
+These residues must be defined as ``ATOM`` records
+in PDB files for HADDOCK3.
+"""
+
+# non-ion residue names
+supported_non_ions = set(it.chain(
+    supported_ATOM,
+    supported_carbo_resnames,
+    supported_fragments_resnames,
+    supported_hemes_resnames,
+    supported_solvents_resnames,
+    supported_shape_resnames,
+    supported_cofactors_resnames,
+    ))
+
+# Residues that must be set as HETATM
+supported_HETATM = set(it.chain(
+    supported_carbo_resnames,
+    supported_fragments_resnames,
+    supported_hemes_resnames,
+    supported_single_ions_resnames,
+    supported_multiatom_ions_resnames,
+    supported_solvents_resnames,
+    supported_cofactors_resnames,
+    ))
+"""
+Supported ``HETATM`` residues.
+
+These residues must be defined as ``HETATM`` records
+in PDB files for HADDOCK3.
+"""
+
+supported_residues = supported_ATOM.union(supported_HETATM)
+"""All HADDOCK3 supported residues."""
+

.venv_haddock/lib/python3.12/site-packages/haddock/core/typing.py

@@ -0,0 +1,197 @@
+"""
+Useful type aliases and type variables for type-hints support.
+
+Visit [PEP 484 Type Hints](https://peps.python.org/pep-0484/) for more help.
+
+Variables endswith `T` are TypeVars for generic function signatures.
+They are defined to
+
+    - accept constraint types(Any type when no type is given)
+    - accept any subclass by using keyword `bound`
+    - be parameter of Generic and subclass of Generic,
+      espacially for invariant Collections(list,sequence and so on).
+    - show more than once in generic functions to indicates that
+      these types are exactly same.
+
+Don't import other classes, type aliases or type variables defined
+in `haddock` into this module.
+This may lead to circular import problem.
+"""
+
+
+from argparse import ArgumentParser, Namespace
+from logging import FileHandler, Handler, StreamHandler
+from pathlib import Path
+from typing import (
+    Any,
+    Callable,
+    Container,
+    Generator,
+    Generic,
+    Iterable,
+    Iterator,
+    Literal,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Protocol,
+    Sequence,
+    Sized,
+    SupportsInt,
+    TextIO,
+    Type,
+    TypedDict,
+    TypeVar,
+    Union,
+    runtime_checkable,
+    )
+
+from numpy import float64
+from numpy.typing import NDArray
+from pandas import DataFrame
+from pandas.core.groupby.generic import DataFrameGroupBy
+from plotly.graph_objects import Figure
+
+
+AnyT = TypeVar('AnyT')
+"""Arbitrary type for generic function signatures."""
+
+PT = TypeVar('PT')
+"""
+Arbitrary parameter type for generic `Callable` signatures.
+
+For py3.11+, `ParamSpec` and `Concatenate` may be more explict
+while making signatures longer.
+"""
+
+# Literals
+ImgFormat = Literal["png", "pdf", "svg", "jpeg", "webp"]
+"""Supported image formats by plotly."""
+
+ExpertLevel = Literal["all", "easy", "expert", "guru"]
+"""The expertise level of the parameters.`hidden` not inclued."""
+
+LogLevel = Literal["INFO", "DEBUG", "ERROR", "WARNING", "CRITICAL"]
+
+
+# Protocols
+@runtime_checkable
+class SupportsAdd(Protocol):
+    """
+    An ABC with one abstract method __add__.
+    
+    Can be used in `isinstance` and `issubclass`.
+
+    Assuming that the operands and the result's types
+    are same for most common situations.
+
+    Examples
+    --------
+
+    >>> isinstance(int, SupportsAdd)
+    True
+    """
+
+    __slots__ = ()
+
+    def __add__(self: AnyT, other: AnyT, /) -> AnyT:
+        raise NotImplementedError()
+
+
+SupportsAddT = TypeVar("SupportsAddT", bound=SupportsAdd)
+"""TypeVar of SupportsAdd for Generic type check."""
+
+
+@runtime_checkable
+class SupportsRun(Protocol):
+    """
+    An ABC with one abstract method run().
+    
+    Can be used in `isinstance` and `issubclass`.
+
+    Examples
+    --------
+
+    >>> from multiprocessing import Process
+    >>> isinstance(Process, SupportsRun)
+    True
+    """
+
+    __slots__ = ()
+
+    def run(self) -> Any:
+        """Do something."""
+        raise NotImplementedError()
+
+
+SupportsRunT = TypeVar("SupportsRunT", bound=SupportsRun)
+"""TypeVar of SupportsRun for Generic type check."""
+
+# other type alias and type variables
+NDFloat = NDArray[float64]
+
+FilePath = Union[str, Path]
+
+FilePathT = TypeVar("FilePathT", bound=FilePath)
+"""
+Generic type variable for file paths.
+
+If the first annotated variable is str,
+the second annotated variable will be str instead of Path,vice versa.
+"""
+
+LineIterSource = Union[Iterable[str], FilePath]
+"""An Object who can generate lines in some way."""
+
+ParamMap = MutableMapping[str, Any]
+"""
+A mutable mapping object contains parameters generated from config
+files or functions.
+
+The keys are always `str`.
+"""
+
+ParamMapT = TypeVar('ParamMapT', bound=ParamMap)
+"""
+Generic type of `MutableMapping[str, Any]` for generic function sigunature.
+"""
+
+ParamDict = dict[str, Any]
+"""
+A dict contains parameters generated from config files or functions.
+
+The keys are always `str`.
+
+Can be called like `dict` and returns a python `dict`.
+
+Examples
+--------
+
+>>> ParamDict(a=1) == {'a':1}
+True
+
+>>> ParamDict({'a':1}) == {'a':1}
+True
+
+>>> ParamDict().setdefault('a', 1)
+1
+"""
+
+ParamDictT = TypeVar('ParamDictT', bound=ParamDict)
+"""
+Generic type of `dict[str, Any]` for generic function sigunature.
+"""
+
+ModuleParams = dict[str, ParamDict]
+"""A dict contains modules' parameters."""
+
+AtomsDict = dict[str, list[str]]
+"""
+A dict contains all kinds of residues' atom type infomations
+(including non-standard residue and atom type).
+
+Key is residue name, value is a list of the residue's atom types.
+"""
+
+StreamHandlerT = TypeVar('StreamHandlerT',
+                         bound=Union[StreamHandler, FileHandler])

.venv_haddock/lib/python3.12/site-packages/haddock/deps/contact_fcc.cpp

@@ -0,0 +1,124 @@
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <map>
+#include <set>
+#include <vector>
+#include <cmath>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace std;
+
+struct Coor3f {
+  float x;
+  float y;
+  float z;
+};
+
+struct Residue {
+  int nr;
+  vector<Coor3f> coor;
+  vector<string> atom;
+  int seg;
+};
+
+vector<Residue> res;
+
+bool seg_sorter (Residue res_a, Residue res_b) {
+  int segA = res_a.seg;
+  int segB = res_b.seg;
+  return (segA < segB);
+};
+
+int main(int argc, char *argv[]) {
+  char buf[2000];
+
+  if (argc < 3) {
+    fprintf(stderr,"ERROR: Too few arguments\n");
+    fprintf(stderr, "Usage: contact <pdb file> <cutoff>\n");
+    return 1;
+  }
+
+  char *filename = argv[1];
+  float cutoff = atof(argv[2]);
+
+  if (cutoff < 0 || cutoff > 100) {
+    fprintf(stderr,"ERROR: Cutoff out of range\n");
+    fprintf(stderr, "Usage: contact <pdb file> <cutoff>\n");
+    return 1;
+  }
+
+  FILE *fil = fopen(filename, "r");
+  if (fil == NULL) {
+    fprintf(stderr, "ERROR: PDB file %s does not exist\n", filename);
+    return 1;
+  }
+  
+  int currnr = -99999;
+  char currseg;
+  int segid = 0;
+
+  set<int> nonconv;
+  while (!feof(fil)) {
+    char code[10];
+    char atom[5];
+    if (!fgets(buf, 2000, fil)) break;
+    sscanf(buf, "%s %*d %s", code, atom);
+
+    // Ignore HETATM and hydrogens
+    if (!strncmp(code,"ATOM", 4) && ( atom[0] != 'H' && !(  isdigit(atom[0]) && atom[1] == 'H' )  )  ) {
+      int nr = atoi(buf + 22);
+      char seg = buf[72];
+      if (seg != currseg) {
+        currseg = seg;
+        segid++;
+      }
+      if (nr != currnr) {
+          Residue r;
+          r.nr = nr+10000;
+    	    r.seg = segid;
+  	      res.push_back(r);
+  	      currnr = r.nr;
+      }
+      Residue &rcurr = res[res.size() -1];
+      Coor3f ccoor;
+      ccoor.x = atof(buf+27);
+      ccoor.y = atof(buf+38);
+      ccoor.z = atof(buf+46);
+      rcurr.coor.push_back(ccoor);
+      string atom2(atom);
+      rcurr.atom.push_back(atom2);
+    }
+  }
+
+  if (!res.size()) {fprintf(stderr, "ERROR: PDB file %s contains no residues\n", filename); return 1;}
+
+  // Sort the residues by segment to avoid random chain ordering problems
+  sort (res.begin(), res.end(), seg_sorter);
+
+  double cutoffsq = cutoff * cutoff;
+
+  for (int n = 0; n < res.size(); n++) {
+    vector<Coor3f> &c1 = res[n].coor;
+    int seg1 = res[n].seg;
+    for (int nn = n + 1; nn < res.size(); nn++) {
+      int seg2 = res[nn].seg;
+      if (seg1 == seg2) continue;
+      vector<Coor3f> &c2 = res[nn].coor;
+      for (int i = 0; i < res[n].coor.size(); i++) {
+        for (int ii = 0; ii < res[nn].coor.size(); ii++) {
+	  double currdissq =
+	    (c1[i].x - c2[ii].x) * (c1[i].x - c2[ii].x) +
+	    (c1[i].y - c2[ii].y) * (c1[i].y - c2[ii].y) +
+	    (c1[i].z - c2[ii].z) * (c1[i].z - c2[ii].z);
+	   if (currdissq < cutoffsq) {
+	     printf ("%d%d%d%d\n", res[n].nr, res[n].seg, res[nn].nr, res[nn].seg);
+	   }
+        }
+      }
+    }
+  }
+  fclose(fil);
+}

.venv_haddock/lib/python3.12/site-packages/haddock/deps/fast-rmsdmatrix.c

@@ -0,0 +1,883 @@
+#define  _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <limits.h>
+#include <stdbool.h>
+
+typedef struct traj{
+    int frames;             /*!< number of frames in the trajectory */
+    double **traj_coords;   /*!< 2D array of xyz coordinates */
+    int n_at;               /*!< number of atoms in the atomistic structure */
+    int pairs;              /*!< number of possible pairs of structures */
+}traj;
+
+typedef struct alignments{
+    double *rmsd_mat;           /*!< condensed pairwise RMSD matrix */
+    double **coms;              /*!< array of centers of mass */
+    int *ref_structs;           /*!< array of reference structures */
+    int *mod_structs;           /*!< array of model structures */
+}alignments;
+
+void failed(char message[]) {
+    printf("\n FAILED *** %s ***\n \n", message);
+    exit(1);
+}
+
+struct arguments;
+
+void zero_vec_d(double *a, int dim) {
+
+    int i;
+    for (i = 0; i < dim; i++) {
+        a[i] = 0;
+    }
+}
+
+int *i1t(int n1) {
+    int *p, *a;
+    int i;
+    if ((p = (int *) malloc((size_t) n1 * sizeof(int))) == NULL)
+        failed("i1t: failed");
+    for (i = 0, a = p; i < n1; i++)
+        *a++ = 0;
+    return p;
+}
+
+double *d1t(int n1) {
+    double *p, *a;
+    int i;
+    if ((p = (double *) malloc((size_t) n1 * sizeof(double))) == NULL)
+        failed("d1t: failed n1 ");
+    for (i = 0, a = p; i < n1; i++)
+        *a++ = 0;
+    return p;
+}
+
+double **d2t(int n1, int n2) {
+    double **p, *a;
+    int i;
+    if ((p = (double **) malloc((size_t) n1 * sizeof(double *))) == NULL)
+        failed("d2t: failed n1");
+    if ((p[0] = (double *) malloc((size_t) n1 * n2 * sizeof(double))) == NULL)
+        failed("d2t: failed n2");
+    for (i = 0; i < n1 - 1; i++)
+        p[i + 1] = p[i] + n2;
+    for (i = 0, a = p[0]; i < n1 * n2; i++)
+        *a++ = 0;
+    return p;
+}
+
+void free_d2t(double **p) {
+
+    free(p[0]);
+    free(p);
+}
+
+void free_d1t(double *p) {
+
+    free(p);
+}
+
+double scal_d(double *a, double *b, int dim) {
+
+    int i;
+    double temp;
+
+    temp = 0.0;
+    for (i = 0; i < dim; i++) {
+        temp += a[i] * b[i];
+    }
+    return (temp);
+}
+
+double norm_d(double *a, int dim) {
+
+    return (sqrt(scal_d(a, a, dim)));
+}
+
+void normalize_d(double *a, int dim) {
+    int i;
+    double temp;
+
+    temp = norm_d(a, dim);
+    for (i = 0; i < dim; i++) {
+        a[i] = a[i] / temp;
+    }
+}
+
+void vecprod_d(double *a, double *b, double *c) {
+
+    c[0] = a[1] * b[2] - a[2] * b[1];
+    c[1] = a[2] * b[0] - a[0] * b[2];
+    c[2] = a[0] * b[1] - a[1] * b[0];
+}
+
+void myjacobi(double a[][3], int n, double *d, double v[][3], int *nrot) {
+
+    int j, iq, ip, i;
+    double tresh, theta, tau, t, sm, s, h, g, c;
+    double b[3], z[3];
+
+#define ROTATE(a, i, j, k, l) g=a[i][j];h=a[k][l];a[i][j]=g-s*(h+g*tau);a[k][l]=h+s*(g-h*tau);
+
+    for (ip = 0; ip <= (n - 1); ip++) {
+        for (iq = 0; iq <= (n - 1); iq++)
+            v[ip][iq] = 0.0;
+        v[ip][ip] = 1.0;
+    }
+    for (ip = 0; ip <= (n - 1); ip++) {
+        b[ip] = d[ip] = a[ip][ip];
+        z[ip] = 0.0;
+    }
+    *nrot = 0;
+    for (i = 1; i <= 500; i++) {
+        sm = 0.0;
+        for (ip = 0; ip <= n - 2; ip++) {
+            for (iq = ip + 1; iq <= (n - 1); iq++)
+                sm += fabs(a[ip][iq]);
+        }
+        if (sm == 0.0) {
+            return;
+        }
+        if (i < 4)
+            tresh = 0.2 * sm / (n * n);
+        else
+            tresh = 0.0;
+        for (ip = 0; ip <= n - 2; ip++) {
+            for (iq = ip + 1; iq <= (n - 1); iq++) {
+                g = 100.0 * fabs(a[ip][iq]);
+                if (i > 4 && (fabs((fabs(d[ip]) + g) - fabs(d[ip])) < 1.0e-6)
+                    && (fabs((fabs(d[iq]) + g) - fabs(d[iq])) < 1.0e-6))
+                    a[ip][iq] = 0.0;
+                else if (fabs(a[ip][iq]) > tresh) {
+                    h = d[iq] - d[ip];
+                    if (fabs((fabs(h) + g) - fabs(h)) < 1.0e-6)
+                        t = (a[ip][iq]) / h;
+                    else {
+                        theta = 0.5 * h / (a[ip][iq]);
+                        t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
+                        if (theta < 0.0)
+                            t = -t;
+                    }
+                    c = 1.0 / sqrt(1 + t * t);
+                    s = t * c;
+                    tau = s / (1.0 + c);
+                    h = t * a[ip][iq];
+                    z[ip] -= h;
+                    z[iq] += h;
+                    d[ip] -= h;
+                    d[iq] += h;
+                    a[ip][iq] = 0.0;
+                    for (j = 0; j <= ip - 1; j++) {
+                        ROTATE (a, j, ip, j, iq)
+                    }
+                    for (j = ip + 1; j <= iq - 1; j++) {
+                        ROTATE (a, ip, j, j, iq)
+                    }
+                    for (j = iq + 1; j <= (n - 1); j++) {
+                        ROTATE (a, ip, j, iq, j)
+                    }
+                    for (j = 0; j <= (n - 1); j++) {
+                        ROTATE (v, j, ip, j, iq)
+                    }
+                    ++(*nrot);
+                }
+            }
+        }
+        for (ip = 0; ip <= (n - 1); ip++) {
+            b[ip] += z[ip];
+            d[ip] = b[ip];
+            z[ip] = 0.0;
+        }
+    }
+    printf("Too many iterations in routine JACOBI %lf\n", sm);
+    /*  exit (1); */
+#undef ROTATE
+}
+
+int columns(char* string){
+    /**
+    * routine that returns the number of columns for each row inside the file chosen.
+    *
+    * Parameter
+    * ----------
+    *
+    * `string`   : string token in account
+    */
+ 
+    int counter = 0;
+
+    while(string){
+        counter++;
+        string = strtok(NULL, " \t\v\r\n");
+    }
+    return counter;
+}
+
+int n_rows (FILE *f){
+    /**
+    * routine that returns the number of rows in a file. It counts correctly this number even if the last row does not present \n
+    *
+    * Parameter
+    * ----------
+    *
+    * `f` : FILE structure that represents the file opened.
+    */
+ 
+    size_t rows_i = 0, n = 0;
+    char *buf = NULL;
+
+    fseek(f, 0, SEEK_SET);
+
+    while(getline(&buf, &n, f) != -1) rows_i++;
+
+    free(buf);
+
+    return rows_i;
+}
+
+int get_pair(int nmodels, int idx, int ij_arr[2]){
+    if (nmodels < 0 || idx < 0){
+        printf("get_pair cannot accept negative numbers");
+        printf("Input is %d , %d", nmodels, idx);
+        exit(EXIT_FAILURE);
+    }
+    // solve the second degree equation
+    int b = 1 - (2 * nmodels);
+    int i = (-b - sqrt(b * b - 8 * idx)) / 2;
+    int j = idx + i * (b + i + 2) / 2 + 1;
+    ij_arr[0] = i;
+    ij_arr[1] = j;
+    return 0;
+} 
+
+double optimal_alignment(double **x, double **y, int cgnum, double u[][3]) {
+    /**
+    * routine that computes the Kabsch alignment and the rmsd between two configurations
+    * 
+    *
+    * Parameters
+    * ----------
+    * 
+    * `x`, `y` : CG structures
+    * 
+    * `cgnum` : length of CG mapping
+    * 
+    * `u` : rotation matrix
+    */
+    void myjacobi(double a[][3], int n, double *d, double v[][3], int *nrot);
+    int i, j, k, sign[3], order[3], nrot;
+    double e, e0;
+    double r[3][3], rt[3][3], temp; //, **x, **y;
+    double a[3][3], eval[3], evec[3][3];
+    double eigenvalues[3], eigenvectors[3][3], b[3][3];
+    int speak = 1;
+
+    e0 = 0.0;
+    for (i = 0; i < cgnum; i++) {
+        e0 += 0.5 * norm_d(x[i], 3) * norm_d(x[i], 3);
+        e0 += 0.5 * norm_d(y[i], 3) * norm_d(y[i], 3);
+    }
+
+    for (i = 0; i < 3; i++) {
+        for (j = 0; j < 3; j++) {
+            r[i][j] = 0.0;
+            for (k = 0; k < cgnum; k++) {
+                r[i][j] += y[k][i] * x[k][j];
+            }
+            rt[j][i] = r[i][j];
+        }
+    }
+
+    if (isnan(e0) == 1) printf("Found a NaN in Kabsch alignment at checkpoint 1\n");
+
+    for (i = 0; i < 3; i++) {
+        for (j = 0; j < 3; j++) {
+            a[i][j] = 0;
+            for (k = 0; k < 3; k++) {
+                a[i][j] += rt[i][k] * r[k][j];
+            }
+        }
+    }
+
+    myjacobi(a, 3, eval, evec, &nrot);
+    /* we add small quantities in order to remove potentially dangerous degeneracies */
+    if (isnan(eval[0]) == 1) printf("Found a NaN in Kabsch alignment at checkpoint 2\n");
+    if (isnan(eval[1]) == 1) printf("Found a NaN in Kabsch alignment at checkpoint 3\n");
+    if (isnan(eval[2]) == 1) printf("Found a NaN in Kabsch alignment at checkpoint 4\n");
+
+    eval[0] += 0.0000000000000001;
+    eval[1] += 0.00000000000000001;
+    eval[2] += 0.00000000000000002;
+
+    if ((eval[0] < eval[1]) && (eval[0] < eval[2])) {
+        order[0] = 1;
+        order[1] = 2;
+        order[2] = 0;
+    }
+
+    if ((eval[1] < eval[0]) && (eval[1] < eval[2])) {
+        order[0] = 0;
+        order[1] = 2;
+        order[2] = 1;
+    }
+
+    if ((eval[2] < eval[0]) && (eval[2] < eval[1])) {
+        order[0] = 0;
+        order[1] = 1;
+        order[2] = 2;
+    }
+
+    for (i = 0; i < 3; i++) {
+        eigenvalues[i] = eval[order[i]];
+        for (j = 0; j < 3; j++) {
+            eigenvectors[i][j] = evec[j][order[i]];
+        }
+    }
+
+    normalize_d(eigenvectors[0], 3);
+    normalize_d(eigenvectors[1], 3);
+    vecprod_d(eigenvectors[0], eigenvectors[1], eigenvectors[2]);
+    normalize_d(eigenvectors[2], 3);
+
+    for (i = 0; i < 2; i++) {
+        for (j = 0; j < 3; j++) {
+            b[i][j] = 0;
+            for (k = 0; k < 3; k++) {
+                b[i][j] += r[j][k] * eigenvectors[i][k];
+            }
+        }
+        normalize_d(b[i], 3);
+    }
+
+    vecprod_d(b[0], b[1], b[2]);
+    normalize_d(b[2], 3);
+
+    temp = 0.0;
+    for (i = 0; i < 3; i++) {
+        for (j = 0; j < 3; j++) {
+            temp += b[2][i] * r[i][j] * eigenvectors[2][j];
+        }
+    }
+    sign[2] = +1;
+    if (temp < 0)
+        sign[2] = -1;
+    sign[0] = sign[1] = 1;
+
+    if (fabs(eigenvalues[2]) < 0.0000001) {
+        e = e0 - sqrt(eigenvalues[0]) - sqrt(eigenvalues[1]);
+    } else {
+        e = e0 - sqrt(eigenvalues[0]) - sqrt(eigenvalues[1]) - sign[2] * sqrt(eigenvalues[2]);
+    }
+
+    if (isnan(e) == 1) {
+        printf("Found a NaN in Kabsch alignment at checkpoint 5 | \n");
+        printf("e %lf e0 %lf e1 %lf e2 %lf e3 %lf\n", e, e0, eigenvalues[0], eigenvalues[1], eigenvalues[2]);
+    }
+/********************/
+    e = 2.0 * e / cgnum;
+    if (e < 0.0) {
+        if (fabs(e) < 1.0e-3) {
+            if (speak == 1) {
+                //printf("Warning. In Kabsch alignment found slightly negative value of e (%e). Identical structures? Setting it to 0.000001.\n",
+                //       e);
+                e = 0.000001;
+            }
+        }
+            /* occasionally, when dealing with two practically identical configurations
+                the value of e may be slightly negative due to the small offsets and roundoff errors.
+                In this case we set it equal to zero. */
+        else {
+            FILE *fe; 
+            fe = fopen("error.dat", "w");
+            fprintf(fe, "Error. In Kabsch alignment found negative value of e: (%lf)\n", e);
+            printf("Error. In Kabsch alignment found negative value of e: (%lf)\n", e);
+            fclose(fe);
+            exit(EXIT_FAILURE);
+        }
+    }
+    e = sqrt(e);
+    if (isnan(e) == 1) printf("Found a NaN in Kabsch alignment at checkpoint 6\n");
+/********************/
+    // filling rotation_matrix
+    for (i = 0; i < 3; i++) {
+        for (j = 0; j < 3; j++) {
+            u[i][j] = 0.0;
+            for (k = 0; k < 3; k++) {
+                u[i][j] += b[k][i] * eigenvectors[k][j];
+            }
+        }
+    }
+    return (e);
+}
+
+void cycle_ilrmsd(traj *Trajectory, traj *Ligand_Trajectory, alignments *align, int start_pair[2]) {
+    /**
+    * routine that cycles over pairs of frames in a trajectory, aligning on the receptor
+    * and computing the interface ligand rmsd
+    * 
+    * Parameters
+    * ----------
+    * 
+    * `Trajectory` : traj object
+    * 
+    * `align` : alignments object
+    * 
+    * `start_pair` : pair of structures to begin with
+    */
+    int n;
+    int i, j;
+    double **x, **y, **xlig, **ylig, **ylig_rot;
+    double u[3][3], cm1[3], cm2[3];
+    int rot_idx;
+    // allocating vectors
+    x = d2t(Trajectory->n_at, 3);
+    xlig = d2t(Ligand_Trajectory->n_at, 3);
+    y = d2t(Trajectory->n_at, 3);
+    ylig = d2t(Ligand_Trajectory->n_at, 3);
+    ylig_rot = d2t(Ligand_Trajectory->n_at, 3);
+    int ref = start_pair[0];
+    int mod = start_pair[1];
+    int old_ref = ref - 1;
+
+    for (n = 0; n < Trajectory->pairs; n++) {
+        if (ref != old_ref) {
+            // recalculate com and translate structure
+            zero_vec_d(cm1, 3);
+            for (i = 0; i < Trajectory->n_at; i++) {
+                for (j = 0; j < 3; j++) {
+                    cm1[j] += Trajectory->traj_coords[ref][i * 3 + j] / Trajectory->n_at;
+                }
+            }
+            // filling structure
+            for (i = 0; i < Trajectory->n_at; i++) {
+                for (j = 0; j < 3; j++) {
+                    x[i][j] = Trajectory->traj_coords[ref][i * 3 + j] - cm1[j];
+                }
+            }
+            // now the ligand
+            for (i = 0; i < Ligand_Trajectory->n_at; i++) {
+                for (j = 0; j < 3; j++) {
+                    xlig[i][j] = Ligand_Trajectory->traj_coords[ref][i * 3 + j] - cm1[j];
+                }
+            }
+            old_ref += 1;
+        }
+        
+        // second structure
+        zero_vec_d(cm2, 3);
+        for (i = 0; i < Trajectory->n_at; i++) {
+                for (j = 0; j < 3; j++) {
+                    cm2[j] += Trajectory->traj_coords[mod][i * 3 + j] / Trajectory->n_at;
+            }
+        }
+        for (i = 0; i < Trajectory->n_at; i++) {
+            for (j = 0; j < 3; j++) {
+                y[i][j] = Trajectory->traj_coords[mod][i * 3 + j] - cm2[j];
+            }
+        }
+        // now ylig
+        for (i = 0; i < Ligand_Trajectory->n_at; i++) {
+            for (j = 0; j < 3; j++) {
+                ylig[i][j] = Ligand_Trajectory->traj_coords[mod][i * 3 + j] - cm2[j];
+            }
+        }
+
+        // Alignment AND RMSD computation
+        align->rmsd_mat[n] = optimal_alignment(x, y, Trajectory->n_at, u);
+        align->ref_structs[n] = ref + 1;
+        align->mod_structs[n] = mod + 1;
+        
+        // now correcting the coordinates of the ligand
+        for (i = 0; i < Ligand_Trajectory->n_at; i++) {
+            for (j = 0; j < 3; j++) {
+                ylig_rot[i][j] = 0.0;
+                for (rot_idx = 0; rot_idx < 3; rot_idx++) {
+                  ylig_rot[i][j] += u[rot_idx][j] * ylig[i][rot_idx];
+                }
+            }
+        }
+        // calculate rmsd between ligands
+        double ilrmsd = 0.0;
+        double delta;
+        for (i = 0; i < Ligand_Trajectory->n_at; i++) {
+            for (j = 0; j < 3; j++) {
+                delta = ylig_rot[i][j] - xlig[i][j];
+                ilrmsd += delta * delta;
+            }
+        }
+
+        ilrmsd = sqrt(ilrmsd / Ligand_Trajectory->n_at);
+        // the value before was the receptor interface rmsd, now let's change it to the ligand interface rmsd
+        align->rmsd_mat[n] = ilrmsd;
+
+        // update idx
+        if (mod == Trajectory->frames - 1) {
+            ref += 1;
+            mod = ref + 1;
+        }
+        else {
+            mod += 1;
+        }
+        
+    }
+    free_d2t(x);
+    free_d2t(y);
+    free_d2t(xlig);
+    free_d2t(ylig);
+    free_d2t(ylig_rot);
+}
+
+void cycle_rmsd(traj *Trajectory, alignments *align, int start_pair[2]) {
+    /**
+    * routine that cycles over all pairs of frames in a trajectory, calling `optimal_alignment`
+    * 
+    * Parameters
+    * ----------
+    * 
+    * `Trajectory` : traj object
+    * 
+    * `align` : alignments object
+    * 
+    * `start_pair` : pair of structures to begin with
+    */ 
+    int n;
+    int i, j;
+    double **x, **y;
+    double u[3][3], cm1[3], cm2[3];
+    printf("calculating rotation matrices..\n");
+    // allocating vectors
+    x = d2t(Trajectory->n_at, 3);
+    y = d2t(Trajectory->n_at, 3);
+    int ref = start_pair[0];
+    int mod = start_pair[1];
+    int old_ref = ref - 1;
+    //for (n = 0; n < Trajectory->frames; n++) {
+    for (n = 0; n < Trajectory->pairs; n++) {
+        if (ref != old_ref) {
+            // recalculate com and translate structure
+
+            zero_vec_d(cm1, 3);
+            for (i = 0; i < Trajectory->n_at; i++) {
+                for (j = 0; j < 3; j++) {
+                    cm1[j] += Trajectory->traj_coords[ref][i * 3 + j] / Trajectory->n_at;
+                }
+            }
+            // filling structure
+            for (i = 0; i < Trajectory->n_at; i++) {
+                for (j = 0; j < 3; j++) {
+                    x[i][j] = Trajectory->traj_coords[ref][i * 3 + j] - cm1[j];
+                }
+            }
+            old_ref += 1;
+        }
+        // second structure
+        zero_vec_d(cm2, 3);
+        for (i = 0; i < Trajectory->n_at; i++) {
+                for (j = 0; j < 3; j++) {
+                    cm2[j] += Trajectory->traj_coords[mod][i * 3 + j] / Trajectory->n_at;
+            }
+        }
+        for (i = 0; i < Trajectory->n_at; i++) {
+            for (j = 0; j < 3; j++) {
+                y[i][j] = Trajectory->traj_coords[mod][i * 3 + j] - cm2[j];
+            }
+        }
+        // Alignment AND RMSD computation
+        align->rmsd_mat[n] = optimal_alignment(x, y, Trajectory->n_at, u);
+        align->ref_structs[n] = ref + 1;
+        align->mod_structs[n] = mod + 1;
+        
+        // update idx
+        if (mod == Trajectory->frames - 1) {
+            ref += 1;
+            mod = ref + 1;
+        }
+        else {
+            mod += 1;
+        }
+        
+    }
+    free_d2t(x);
+    free_d2t(y);
+}
+
+void read_TrajectoryFile(char *TrajFileName, traj *Trajectory){
+    /**
+    * routine that reads the input xyz coordinate file
+    *
+    * Parameters
+    * ----------
+    *
+    * `TrajFileName` : trajectory filename
+    *
+    * `Trajectory` : traj object
+    */
+ 
+    FILE *ft;                   // trajectory file; 
+    FILE *fe;                   // declaring error file;  
+
+    int rows_i, cols_i, i, p, frame_idx, j, count; 
+    size_t line_buf_size = 0;
+
+    char *token;
+    char *token_arr[100];  //*string, *line;
+    char *string = NULL; 
+    char *line;  
+
+    /* Opening and check if it exist and if it is empty */
+    ft = fopen(TrajFileName, "r");
+    printf("Reading Trajectory FILE %s\n", TrajFileName);
+
+    //check_empty_file(ft, TrajFileName);
+
+    rows_i = n_rows(ft);                                // Number of rows in trajectory file "ft".
+    fseek(ft, 0, SEEK_SET);
+   
+    line   = (char *) malloc (200); 					     // Allocate char line with size (lenght) = 200; 
+									     // We are sure that the lenght of each line is less than 200
+
+    /* Initialize the 2D-array Trajectory->traj_coords[][] */
+    for(i = 0; i < Trajectory->frames; i++){
+        for(j = 0; j < Trajectory->n_at; j++){
+            Trajectory->traj_coords[i][3 * j + 0] = 0.0;
+            Trajectory->traj_coords[i][3 * j + 1] = 0.0;
+            Trajectory->traj_coords[i][3 * j + 2] = 0.0;
+        }
+    }
+
+    /* Checking for empty rows; 
+     * Checking that there are ONLY rows with one column and three columns 
+     * Checking that the rows with one column correspond to an integer number i.e. the number of atoms; 
+     * Checking that the rows with three columns are float corresponding to x,y,z trajectory coordinate. */
+
+    frame_idx = 0;                                      // Initialize frame index to  0 
+    p  = 0;                                             // Initialize counter "p" to 0 
+
+    for(i=0; i<rows_i; i++){
+        if(p>=3*Trajectory->n_at)                       // p increases from 0 to 3*atomnum i.e. p=[0;3*230) i.e. p = [0;689]
+            p = 0; 
+
+        getline(&string, &line_buf_size, ft);           // Reading entire line;   
+   
+        strcpy(line, string);                           // Copying "string" in "line"; we need it in case of three columns. 
+
+        //if( i != (Trajectory->n_at + 2)*(frame_idx-1) + 1)  // Checking for empty rows except for the 2nd row of each frame representing the title
+        //    check_empty_rows(string);                   // that could also be an empty string   
+
+        token = strtok(string, " \t\v\r\n");            // Splitting the string-line in columns separated by spaces, tabs, or \n  or \v or \r
+
+        cols_i = columns(token);                        // Counting the number of columns in each row of file.  
+
+         
+        if(i!=(Trajectory->n_at + 2)*(frame_idx-1) + 1){   // exclude the 2nd row of each frame 
+
+            if(cols_i == 1){
+
+                if(i != (Trajectory->n_at + 2)*frame_idx) {
+                    printf("Error. The %dth frame contains a different number of rows. Each frame must have %d rows\n", frame_idx+1, Trajectory->n_at + 2);
+                    exit(EXIT_FAILURE);
+                } 
+                else{
+                    frame_idx++;
+                    if(frame_idx>Trajectory->frames){
+                        fe = fopen("error.dat", "w");
+                        fprintf(fe, "Error. The number of trajectory frames is higher than the declared one in parameter file (%d).\nAborting\n", Trajectory->frames);
+                    	fclose(fe);
+                    	printf("Error. The number of trajectory frames is higher than the declared one in parameter file (%d).\nAborting\n", Trajectory->frames);
+                    	exit(EXIT_FAILURE);
+                    }
+                    //check_int_string(string, i, TrajFileName);             // Checking that each row is an INTEGER number. 
+                    if(atoi(string) != Trajectory->n_at){
+                        fe = fopen("error.dat","w");
+                    	fprintf(fe,"Error. The number of atoms at %dth row has length (%d) different from atomnum(%d). Aborting\n",\
+                                i+1,atoi(string),Trajectory->n_at);
+                   	 printf("Error. The number of atoms at %dth row has length (%d) different from atomnum(%d). Aborting\n",\
+                                     i+1,atoi(string),Trajectory->n_at);
+                    	fclose(fe); 
+                    	exit(EXIT_FAILURE);
+                    }
+                }
+            }
+    
+            if(cols_i == 2){
+ 
+                if(i != (Trajectory->n_at + 2)*frame_idx + 1){
+                    fe = fopen("error.dat", "w");
+                    fprintf(fe,"Error. Each row must not contain 2 columns (except the title in the 2nd row of each frame that can contain N columns).\n\
+                      	        ONLY 1 or 4 columns are allowed in Trajectory (%dth row has 2 columns)\n", i+1);
+
+                    printf("Error. Each row must not contain 2 columns (except the title in the 2nd row of each frame that can contain N columns)\n\
+                            ONLY 1 or 4 columns are allowed in Trajectory (%dth row has 2 columns.\n", i+1);
+                    fclose(fe); 
+                    exit(EXIT_FAILURE);
+                }
+            }
+
+            if(cols_i == 3){
+ 
+                if(i != (Trajectory->n_at + 2)*frame_idx + 1){
+                    fe = fopen("error.dat", "w");
+                    fprintf(fe,"Error. Each row must not contain 3 columns (except the title in the 2nd row of each frame that can contain N columns). \
+                                ONLY 1 or 4 columns are allowed in Trajectory (%dth row has 3 columns)\n", i+1);
+
+                    printf("Error. Each row must not contain 3 columns (except the title in the 2nd row of each frame that can contain N columns) \
+                            ONLY 1 or 4 columns are allowed in Trajectory (%dth row has 3 columns.\n", i+1);
+                    fclose(fe); 
+                    exit(EXIT_FAILURE);
+                }
+            }
+
+            if(cols_i == 4){ 
+                if(i != (Trajectory->n_at + 2)*frame_idx){
+                    token_arr[0] = strtok(line, " \t\v\r\n");
+
+                    count = 0;  
+                    while(token_arr[count]){
+                        count++; 
+                        token_arr[count] = strtok(NULL, " \t\v\r\n");
+                    }
+
+                    for (j=1; j <= count-1 ; j++){
+                        //check_float_string(token_arr[j], i, TrajFileName);                     // Checking that each row is an FLOAT number.
+                        Trajectory->traj_coords[frame_idx-1][p] = atof(token_arr[j]);          // Assigning each float-string to traj_coords[i][j] 2D-array 
+                        p++;
+                    }
+
+                }
+
+                else{ 
+                    printf("Error. Each row of the frame (except the 1st row containing the number of atoms and the 2nd row containing the title),\n\
+                    must contain 4 columns corresponding to at_name, x, y, and z coodinates. Check also if there is one extra row in %dth frame\n",
+                            frame_idx); 
+                    exit(EXIT_FAILURE);
+                }
+            }
+
+            if(cols_i > 4 ){ 
+                if(i != (Trajectory->n_at + 2)*frame_idx){ 
+                    fe = fopen("error.dat","w"); 
+                    fprintf(fe,     "Error. The maximum number of columns allowed is 4. The %dth row of your file contains %d columns\n", i+1, cols_i);
+                    printf("Error. The maximum number of columns allowed is 4. The %dth row of your file contains %d columns\n", i+1, cols_i);
+                    fclose(fe); 
+                    exit(EXIT_FAILURE);
+                }
+            }
+        }
+
+    }  // END FOR LOOP 
+    
+    free(string);
+    //free(token);
+    free(line);
+    fclose(ft);// Close trajectory file. 
+    // 1st check: frame_idx must be = frames
+    if (frame_idx !=  Trajectory->frames) {
+        fe = fopen("error.dat", "w");
+        fprintf(fe, "Error. Frames completed: %d, while declared frames in parameter file are %d. Trajectory incomplete.\nAborting\n",frame_idx,\
+                     Trajectory->frames);
+        fclose(fe);
+        printf("Error. Frames completed: %d, while declared frames in parameter file are %d. Trajectory incomplete.\nAborting\n",frame_idx,\
+                Trajectory->frames);
+        exit(EXIT_FAILURE);
+    }
+
+    // final check: frame_idx corresponds with what we expect but the number of row is not the same => It means that 
+    //              the frame completed are frame_idx - 1 
+    else{
+        if(rows_i !=  (Trajectory->n_at + 2)*Trajectory->frames){
+            fe = fopen("error.dat", "w");
+            fprintf(fe,"Error. Total number of rows: %d, while expected number of rows are %d. Trajectory incomplete.\nAborting\n",rows_i,\
+                        (Trajectory->n_at + 2)*Trajectory->frames);
+            fclose(fe);
+            printf("Error. Total number of rows: %d, while expected number of rows are %d. Trajectory incomplete.\nAborting\n", rows_i,\
+                    (Trajectory->n_at + 2)*Trajectory->frames);
+            exit(EXIT_FAILURE);
+        }
+    }
+}
+
+
+int main(int argc, char *argv[]) {
+    /**
+    * main file of the program
+    */
+    time_t seconds;
+    time_t seconds_ref = time(NULL);
+    printf("Starting program at %s\n", ctime(&seconds_ref));
+
+    printf("input trajectory %s\n", argv[1]);
+    printf("core index is %s\n", argv[2]);
+    printf("number of pairs is %s\n", argv[3]);
+    printf("starting pair is %s-%s\n", argv[4], argv[5]);
+    traj *Trajectory = malloc (sizeof(traj));
+
+    int npairs = atoi(argv[3]);
+    int start_pair[2];
+    start_pair[0] = atoi(argv[4]);
+    start_pair[1] = atoi(argv[5]);
+
+    int rec_frames = atoi(argv[6]);
+    int rec_atomnum = atoi(argv[7]);
+     
+    Trajectory->frames = rec_frames;
+    Trajectory->n_at = rec_atomnum;
+    Trajectory->traj_coords = d2t(rec_frames, 3 * rec_atomnum);
+    Trajectory->pairs = npairs;
+    
+    printf("frames = %d\n", Trajectory->frames);
+    printf("overall pairs = %d\n", Trajectory->pairs);
+    
+    // read trajectory
+    read_TrajectoryFile(argv[1], Trajectory);
+    alignments *align = malloc (sizeof(alignments));
+    align->rmsd_mat = d1t(Trajectory->pairs);
+    align->ref_structs = i1t(Trajectory->pairs);
+    align->mod_structs = i1t(Trajectory->pairs);
+    align->coms = d2t(rec_frames, 3);
+
+    char out_filename[100];
+    if (argc == 10){
+        // if there are arguments 8 to 10, it is the ligand trajectory, frames and atomnum
+        traj *Ligand_Trajectory = malloc (sizeof(traj));
+        printf("loading ligand data\n");
+
+        int ligand_atomnum = atoi(argv[9]);
+        Ligand_Trajectory->frames = rec_frames;
+        Ligand_Trajectory->n_at = ligand_atomnum;
+        Ligand_Trajectory->traj_coords = d2t(rec_frames, 3 * ligand_atomnum);
+        read_TrajectoryFile(argv[8], Ligand_Trajectory);
+        cycle_ilrmsd(Trajectory, Ligand_Trajectory, align, start_pair);
+        sprintf(out_filename, "ilrmsd_%s.matrix", argv[2]);
+    }
+    else{
+        cycle_rmsd(Trajectory, align, start_pair);
+        sprintf(out_filename, "rmsd_%s.matrix", argv[2]);
+    }
+    // write the rmsd matrix
+    int i;
+    // check if file exists
+    if (access(out_filename, F_OK) != -1){
+        printf("Warning: file %s already exists.\n", out_filename);
+    }
+    // write to file
+    FILE *frmsd;
+    frmsd = fopen(out_filename, "w");
+    for (i = 0; i < Trajectory->pairs; i++){
+        fprintf(frmsd, "%d %d %.3lf\n",align->ref_structs[i],align->mod_structs[i],align->rmsd_mat[i]);
+    }
+    
+    seconds = time(NULL);
+    printf("\nOverall execution time: %ld seconds\n", seconds-seconds_ref);
+    free_d2t(align->coms);
+    free_d1t(align->rmsd_mat);
+    free(align);
+    free_d2t(Trajectory->traj_coords);
+    free(Trajectory);
+    return 0;
+}

.venv_haddock/lib/python3.12/site-packages/haddock/fcc/calc_fcc_matrix.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8  -*-
+
+"""
+Calculates a matrix of fraction of common contacts between two or more structures.
+
+Authors:
+        RODRIGUES Joao
+        TRELLET Mikael
+        MELQUIOND Adrien
+"""
+
+
+# Contact Parsing routines
+def parse_contact_file(f_list, ignore_chain):
+    """Parses a list of contact files."""
+
+    if ignore_chain:
+        contacts = [
+            [int(l[0:5] + l[6:-1]) for l in open(f)] for f in f_list if f.strip()
+        ]
+    else:
+        contacts = [set([int(l) for l in open(f)]) for f in f_list if f.strip()]
+
+    return contacts
+
+
+# FCC Calculation Routine
+def calculate_fcc(listA, listB):
+    """
+    Calculates the fraction of common elements between two lists
+    taking into account chain IDs
+    """
+
+    cc = len(listA.intersection(listB))
+    cc_v = len(listB.intersection(listA))
+
+    return (cc, cc_v)
+
+
+def calculate_fcc_nc(listA, listB):
+    """
+    Calculates the fraction of common elements between two lists
+    not taking into account chain IDs. Much Slower.
+    """
+
+    largest, smallest = sorted([listA, listB], key=len)
+    ncommon = len([ele for ele in largest if ele in smallest])
+    return (ncommon, ncommon)
+
+
+# Matrix Calculation
+
+
+def calculate_pairwise_matrix(contacts, ignore_chain):
+    """Calculates a matrix of pairwise fraction of common contacts (FCC).
+    Outputs numeric indexes.
+
+    contacts: list_of_unique_pairs_of_residues [set/list]
+
+    Returns pairwise matrix as an iterator, each entry in the form:
+    FCC(cplx_1/cplx_2) FCC(cplx_2/cplx_1)
+    """
+
+    contact_lengths = []
+    for c in contacts:
+        try:
+            ic = 1.0 / len(c)
+        except ZeroDivisionError:
+            ic = 0
+        contact_lengths.append(ic)
+
+    if ignore_chain:
+        calc_fcc = calculate_fcc_nc
+    else:
+        calc_fcc = calculate_fcc
+
+    for i in range(len(contacts)):
+
+        for k in range(i + 1, len(contacts)):
+            cc, cc_v = calc_fcc(contacts[i], contacts[k])
+            fcc, fcc_v = cc * contact_lengths[i], cc * contact_lengths[k]
+            yield (i + 1, k + 1, fcc, fcc_v)
+
+
+def _output_fcc(output, values, f_buffer):
+
+    buf = []
+    for i in values:
+        buf.append(i)
+        if len(buf) == f_buffer:
+            output(
+                "".join(["%s %s %1.3f %1.3f\n" % (i[0], i[1], i[2], i[3]) for i in buf])
+            )
+            buf = []
+    output("".join(["%s %s %1.3f %1.3f\n" % (i[0], i[1], i[2], i[3]) for i in buf]))

.venv_haddock/lib/python3.12/site-packages/haddock/fcc/cluster_fcc.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8  -*-
+
+"""
+Asymmetric Taylor-Butina Disjoint Clustering Algorithm.
+
+Authors:
+           RODRIGUES Joao
+           TRELLET Mikael
+           MELQUIOND Adrien
+"""
+
+
+class Element(object):
+    """Defines a 'clusterable' Element"""
+
+    __slots__ = ["name", "cluster", "neighbors"]
+
+    def __init__(self, name):
+        self.name = name
+        self.cluster = 0
+        self.neighbors = set()
+
+    def add_neighbor(self, neighbor):
+        """Adds another element to the neighbor list"""
+        self.neighbors.add(neighbor)
+
+    def assign_cluster(self, clust_id):
+        """Assigns the Element to Cluster. 0 if unclustered"""
+        self.cluster = clust_id
+
+
+class Cluster(object):
+    """Defines a Cluster. A Cluster is created with a name and a center (Element class)"""
+
+    __slots__ = ["name", "center", "members"]
+
+    def __init__(self, name, center):
+
+        self.name = name
+        self.center = center
+
+        self.members = []
+
+        self.populate()
+
+    def __len__(self):
+        return len(self.members) + 1  # +1 Center
+
+    def populate(self):
+        """
+        Populates the Cluster member list through the
+        neighbor list of its center.
+        """
+
+        name = self.name
+        # Assign center
+        ctr = self.center
+        ctr.assign_cluster(name)
+
+        mlist = self.members
+        # Assign members
+        ctr_nlist = (n for n in ctr.neighbors if not n.cluster)
+        for e in ctr_nlist:
+            mlist.append(e)
+            e.assign_cluster(name)
+
+    def add_member(self, element):
+        """
+        Adds one single element to the cluster.
+        """
+        l = self.members
+        l.append(element)
+        element.assign_cluster(self.name)
+
+
+def read_matrix(path, cutoff, strictness):
+    """
+    Reads in a four column matrix (1 2 0.123 0.456\n)
+    and creates an dictionary of Elements.
+
+    The strictness factor is a <float> that multiplies by the cutoff
+    to produce a new cutoff for the second half of the matrix. Used to
+    allow some variability while keeping very small interfaces from clustering
+    with anything remotely similar.
+    """
+
+    cutoff = float(cutoff)
+    partner_cutoff = float(cutoff) * float(strictness)
+
+    elements = {}
+
+    f = open(path, "r")
+    for line in f:
+        ref, mobi, dRM, dMR = line.split()
+        ref = int(ref)
+        mobi = int(mobi)
+        dRM = float(dRM)
+        dMR = float(dMR)
+
+        # Create or Retrieve Elements
+        if ref not in elements:
+            r = Element(ref)
+            elements[ref] = r
+        else:
+            r = elements[ref]
+
+        if mobi not in elements:
+            m = Element(mobi)
+            elements[mobi] = m
+        else:
+            m = elements[mobi]
+
+        # Assign neighbors
+        if dRM >= cutoff and dMR >= partner_cutoff:
+            r.add_neighbor(m)
+        if dMR >= cutoff and dRM >= partner_cutoff:
+            m.add_neighbor(r)
+
+    f.close()
+
+    return elements
+
+
+def remove_true_singletons(element_pool):
+    """Removes from the pool elements without any neighbor"""
+
+    ep = element_pool
+
+    ts = set([e for e in ep if not ep[e].neighbors])
+
+    # Remove ts from everybody's neighbor list
+    ts_e = set(ep[e] for e in ts)
+    for e in element_pool:
+        ep[e].neighbors = ep[e].neighbors.difference(ts_e)
+
+    # Remove ts from pool
+    for e in ts:
+        del ep[e]
+
+    return (ts, ep)
+
+
+def cluster_elements(element_pool, threshold):
+    """
+    Groups Elements within a given threshold
+    together in the same cluster.
+    """
+
+    clusters = []
+    threshold -= 1  # Account for center
+    ep = element_pool
+    cn = 1  # Cluster Number
+    while 1:
+        # Clusterable elements
+        ce = [e for e in ep if not ep[e].cluster]
+        if not ce:  # No more elements to cluster
+            break
+
+        # Select Cluster Center
+        # Element with largest neighbor list
+        ctr_nlist, ctr = sorted(
+            [(len([se for se in ep[e].neighbors if not se.cluster]), e) for e in ce]
+        )[-1]
+
+        # Cluster until length of remaining elements lists are above threshold
+        if ctr_nlist < threshold:
+            break
+
+        # Create Cluster
+        c = Cluster(cn, ep[ctr])
+        cn += 1
+        clusters.append(c)
+
+    return (ep, clusters)
+
+
+def output_clusters(handle, clusters):
+    """Outputs the cluster name, center, and members."""
+
+    write = handle.write
+
+    for c in clusters:
+        write("Cluster %s -> %s " % (c.name, c.center.name))
+        for m in sorted(c.members, key=lambda k: k.name):
+            write("%s " % m.name)
+        write("\n")

.venv_haddock/lib/python3.12/site-packages/haddock/gear/__init__.py

@@ -0,0 +1,7 @@
+"""
+Contain modules to address specific implementation ideas.
+
+Each python module in this package should encapsulate all specific logic
+regarding on implementation idea. For example, you wish to defined the
+whole logic referring to the preparation steps before the run.
+"""